moved firmext code into the backend dir

[r19036]

diff --git a/ir/be/grgen/Makefile.in b/ir/be/grgen/Makefile.in
new file mode 100644 (file)
index 0000000..110dc8e
--- /dev/null
+++ b/ir/be/grgen/Makefile.in
@@ -0,0 +1,60 @@
+#
+# Project:     libFIRM
+# File name:   ir/arch/Makefile.in
+# Purpose:
+# Author:      Boris Boesler, Till Riedel, Michael Beck, Gernot Veit Batz
+# Modified by:
+# Created:
+# CVS-ID:      $Id$
+# Copyright:   (c) 1999-2003 Universität Karlsruhe
+# Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+#
+
+top_srcdir := @top_srcdir@
+srcdir = @srcdir@
+topdir = ../..
+subdir := ir/ir
+
+INSTALL_HEADERS =      base.h \
+                                       action.h \
+                                       analyze.h \
+                                       ana_vs.h \
+                                       matchplan.h \
+                                       match.h \
+                                       plan_vs_dmst.h \
+                                       grs.h \
+                                       common.h
+
+SOURCES = $(INSTALL_HEADERS)
+
+SOURCES +=     Makefile.in \
+                       base.c \
+                       analyze.c \
+                       auxilary.c \
+                       plan_vs_dmst.c \
+                       ana_vs.c \
+                       matchplan.c \
+                       grshooks.c \
+                       action.c \
+                       match.c
+
+include $(topdir)/MakeRules
+
+CPPFLAGS +=    -I$(top_srcdir)/ir/adt   -I$(top_srcdir)/ir/ir   -I$(top_srcdir)/ir/common  \
+               -I$(top_srcdir)/ir/ident -I$(top_srcdir)/ir/tr   -I$(top_srcdir)/ir/tv \
+               -I$(top_srcdir)/ir/debug -I$(top_srcdir)/ir/ana  -I$(top_srcdir)/ir/st \
+               -I$(top_srcdir)/ir/arch  -I$(top_srcdir)/ir/stat -I$(top_srcdir)/ir/external \
+               -I$(topdir)/ir/config
+
+include $(top_srcdir)/MakeTargets
+
+# override header install
+local_install_headers: $(INCLUDEDIR)/ext/grs
+               $(INSTALL)  -m u+rw,a+r $(addprefix $(srcdir)/,$(INSTALL_HEADERS)) $(INCLUDEDIR)/ext/grs
+
+$(INCLUDEDIR)/ext/grs:
+               mkdir -p $@
+
+all: subdir.o
+
+$(srcdir)/ext/grs/plan_vs_dmst.c: $(srcdir)/ext/grs/uf_mpq.h

diff --git a/ir/be/grgen/action.c b/ir/be/grgen/action.c
new file mode 100644 (file)
index 0000000..407aaad
--- /dev/null
+++ b/ir/be/grgen/action.c
@@ -0,0 +1,1552 @@
+/*
+ * Project:     libFIRM/extension module/GRS-matcher
+ * File name:   ext/action.c
+ * Purpose:     funcytions to construct for libfirm grs actions
+ * Author:      Veit Batz
+ * Modified by: Andreas Schoesser
+ * Created:            29. August 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+#include "common_t.h"
+#include "action_t.h"
+
+
+#define ext_grs_PSEUDO_PREFIX "_pseudo__"
+#undef MAX
+#define MAX(a,b) (a)>=(b) ? (a) : (b)
+
+
+/* counter to create action ids from */
+static int action_counter = 0;
+
+/* obstack to store actions on */
+static struct obstack obst;
+/* tells whether the obstack has already been initialized */
+static int obst_init = 0;
+
+
+
+static int not_injective = 0;
+static int multiple_entry = 0;
+static int already_exists = 0;
+
+
+/* a pointer to pointer map elem */
+typedef struct {
+       /* kind */
+       ext_grs_elem_kind_t kind;
+       /* the preimage */
+       void *pre;
+       /* the image */
+       void *img;
+}
+ext_grs_ptr_map_entry_t;
+
+int ptr_map_cmp_func(const void *elt, const void *key) {
+
+       ext_grs_ptr_map_entry_t *entry1 = (ext_grs_ptr_map_entry_t *) elt;
+       ext_grs_ptr_map_entry_t *entry2 = (ext_grs_ptr_map_entry_t *) key;
+
+       if (entry1->pre != entry2->pre && entry1->img == entry2->img)
+               not_injective = 1;
+
+       if (entry1->pre == entry2->pre && entry1->img != entry2->img)
+               multiple_entry = 1;
+
+       if (entry1->pre == entry2->pre && entry1->img == entry2->img)
+               already_exists = 1;
+
+       return entry1->pre != entry2->pre;
+}
+
+
+
+
+static void init_graph(ext_grs_graph_t *graph,
+ext_grs_action_t *act, ext_grs_graph_kind_t kind)
+{
+       memset(graph, 0, sizeof(*graph));
+
+       graph->kind = kind;
+       graph->action = act;
+       LC_INIT_LIST_HEAD(& graph->nodes);
+       LC_INIT_LIST_HEAD(& graph->edges);
+}
+
+
+/*
+ *  Copy all nodes into the action and gen pseudo edges
+ *  modeling the explicit matching of a node
+ *  PseudoEdge == Edge modelled as a node
+ */
+static int import_graph_info(ext_grs_action_t *action, ext_grs_graph_t *graph)
+{
+       int edge_aiid = action->max_edge_aiid;
+
+       lc_list_t *pos, *n;
+
+       assert (action->kind != ext_grs_k_replacement &&
+               "import_graph_info() is not meant for calling on replacement graphs");
+
+
+       /* init the graphs root node */
+       graph->root_node.kind = ext_grs_k_pseudo_node;
+       graph->root_node.graph = graph;
+       LC_INIT_LIST_HEAD(& graph->root_node.edges[ext_grs_in]);
+       LC_INIT_LIST_HEAD(& graph->root_node.edges[ext_grs_out]);
+       graph->root_node.name = ext_grs_PSEUDO_PREFIX "root_node";
+
+       lc_list_for_each (pos, & graph->nodes) {
+
+               ext_grs_node_t *node = lc_list_entry(pos, ext_grs_node_t, node_list);
+               ext_grs_edge_t *pseudo_edge = obstack_alloc(&obst, sizeof(*pseudo_edge));
+
+               memset(pseudo_edge, 0, sizeof(*pseudo_edge));
+
+               /* store the node in the actions node array */
+               if (action->nodes[node->aiid] == NULL) {
+                       action->nodes[node->aiid] = node;
+               }
+               else {
+                       printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+                       printf("  Multiple assigned node id encountered.\n");
+                       printf("  You may have added nodes with the same id via ext_grs_act_add_node().\n\n");
+                       return 0;
+               }
+
+               /* for each node setup the pseudo edge modeling the
+                * explicit matching of that node */
+               pseudo_edge->graph = graph;
+               pseudo_edge->kind = ext_grs_k_pseudo_edge;
+               pseudo_edge->aiid = ++edge_aiid;
+               pseudo_edge->arg = node;
+               pseudo_edge->func = & graph->root_node;
+               pseudo_edge->genuine_elem.kind = ext_grs_k_node;
+               pseudo_edge->genuine_elem.val.n = node;
+               pseudo_edge->name = obstack_alloc(
+                       & obst,
+                       (1 + strlen(ext_grs_PSEUDO_PREFIX) + strlen(node->name)) * sizeof(char)
+               );
+               strcpy(pseudo_edge->name, ext_grs_PSEUDO_PREFIX);
+               strcat(pseudo_edge->name, node->name);
+
+               /* add the pseudo edge to the graphs edge list */
+               lc_list_add(& pseudo_edge->edge_list, & graph->edges);
+               /* add the pseudo edge to the tgt- and src-nodes  in- and out-lists */
+               lc_list_add(& pseudo_edge->list[ext_grs_in],
+                       & pseudo_edge->func->edges[ext_grs_in]);
+               lc_list_add(& pseudo_edge->list[ext_grs_out],
+                       & pseudo_edge->arg->edges[ext_grs_out]);
+               /* add the pseudo edge to the action */
+               action->edges[edge_aiid] = pseudo_edge;
+       }
+
+       /* copy all pattern edges into the action and for every
+        * edge gen a pseudo edge modeling the traversal of the original edge
+        * against its direction */
+       lc_list_for_each_safe (pos, n, & graph->edges) {
+
+               ext_grs_edge_t *edge = lc_list_entry(pos, ext_grs_edge_t, edge_list);
+               ext_grs_edge_t *pseudo_edge;
+
+               if (edge->kind == ext_grs_k_pseudo_edge)
+                       continue;
+
+               pseudo_edge = obstack_alloc(&obst, sizeof(*pseudo_edge));
+               memset(pseudo_edge, 0, sizeof(*pseudo_edge));
+
+               /* store the node in the actions node array */
+               action->edges[edge->aiid] = edge;
+
+               /* for each edge setup the pseudo edge modelling the
+                * against-direction-traversal of that edge  */
+               pseudo_edge->graph = edge->graph;
+               pseudo_edge->kind = ext_grs_k_pseudo_edge;
+               pseudo_edge->aiid = ++edge_aiid;
+               pseudo_edge->arg = edge->func;
+               pseudo_edge->func = edge->arg;
+               pseudo_edge->genuine_elem.kind = ext_grs_k_edge;
+               pseudo_edge->genuine_elem.val.e = edge;
+               pseudo_edge->name = obstack_alloc(
+                       & obst,
+                       (1 + strlen(ext_grs_PSEUDO_PREFIX) + strlen(edge->name)) * sizeof(char)
+               );
+               strcpy(pseudo_edge->name, ext_grs_PSEUDO_PREFIX);
+               strcat(pseudo_edge->name, edge->name);
+
+               /* add the pseudo edge to the graphs edge list */
+               lc_list_add(& pseudo_edge->edge_list, & graph->edges);
+               /* add the pseudo edge to the tgt- and src-nodes  in- and out-lists */
+               lc_list_add(& pseudo_edge->list[ext_grs_in],
+                       & pseudo_edge->func->edges[ext_grs_in]);
+               lc_list_add(& pseudo_edge->list[ext_grs_out],
+                       & pseudo_edge->arg->edges[ext_grs_out]);
+               /* add the pseudo edge to the action */
+               action->edges[edge_aiid] = pseudo_edge;
+               /* each actual edge knows the respective pseudo edge */
+               edge->backward_edge = pseudo_edge;
+       }
+
+       action->max_edge_aiid = edge_aiid;
+
+       return 1;
+}
+
+
+
+static void set_up_condition_stuff(ext_grs_action_t *action) {
+
+       lc_list_t *pos;
+       int i;
+
+       /* alloc space for bitsets telling which (pattern or negative) nodes and edges
+        * are involved in which conditions and vice versa wich conditions are refered
+        * by which nodes or edges */
+       action->conditions =
+               obstack_alloc(&obst, action->n_conditions * sizeof(*action->conditions));
+       action->conds_involved_nodes =
+               obstack_alloc(&obst, action->n_conditions * sizeof(*action->conds_involved_nodes));
+       action->conds_involved_edges =
+               obstack_alloc(&obst, action->n_conditions * sizeof(*action->conds_involved_edges));
+
+       action->nodes_refering_conds =
+               obstack_alloc(&obst, (action->max_node_aiid+1) * sizeof(*action->nodes_refering_conds));
+       action->edges_refering_conds =
+               obstack_alloc(&obst, (action->max_edge_aiid+1) * sizeof(*action->edges_refering_conds));
+
+       /* alloc a bitset for every (pattern or negative) node and edge */
+       for(i = 0; i <= action->max_node_aiid; i++)
+               action->nodes_refering_conds[i] =
+                       lc_bitset_obstack_alloc(&obst, action->n_conditions);
+       for(i = 0; i <= action->max_edge_aiid; i++)
+               action->edges_refering_conds[i] =
+                       lc_bitset_obstack_alloc(&obst, action->n_conditions);
+
+       /* alloc two bitset for every condition (telling which nodes and edges are involved),
+        * and setup the hole condition information */
+       i = 0;
+       lc_list_for_each(pos, & action->listed_conditions) {
+
+               int j;
+               lc_bitset_t *bs;
+               ext_grs_cond_descr_t *cond_descr =
+                       lc_list_entry(pos, ext_grs_cond_descr_t, condition_list);
+
+               action->conditions[i] = cond_descr->condition;
+
+               /* alloc the bitset, which represents the information about the
+                * (pattern or negative) nodes involved in the current condition */
+               bs = action->conds_involved_nodes[i] =
+                               lc_bitset_obstack_alloc(&obst, action->max_node_aiid+1);
+
+               /* store that info in the bitset */
+               for (j = 0; j < cond_descr->n_nodes; j++) {
+                       int aiid = cond_descr->nodes[j]->aiid;
+                       lc_bitset_set(bs, aiid);
+                       lc_bitset_set(action->nodes_refering_conds[aiid], i);   // CRASH!!!
+               }
+
+               /* alloc the bitset, which represents the information about the
+                * (pattern or negative) edges involved in the current condition */
+               bs = action->conds_involved_edges[i] =
+                               lc_bitset_obstack_alloc(&obst, action->max_edge_aiid+1);
+
+               /* store that info in the bitset */
+               for (j = 0; j < cond_descr->n_edges; j++) {
+                       int aiid = cond_descr->edges[j]->aiid;
+                       lc_bitset_set(bs, aiid);
+                       lc_bitset_set(action->edges_refering_conds[aiid], i);
+               }
+
+               i++;
+       }
+
+       assert(i == action->n_conditions && "inconsistent number of registered condition functions");
+}
+
+
+
+
+
+/** create a new graph action of the given kind */
+ext_grs_action_t *ext_grs_new_action(ext_grs_action_kind_t kind, char *name) {
+
+       ext_grs_action_t *action;
+
+       /* allocate a new action */
+       action = (ext_grs_action_t *) obstack_alloc(&obst, sizeof(*action));
+       if (action == NULL)     {
+               printf("module ext/grs: internal ERROR in function ext_grs_act_allow_nodes_hom()\n");
+               printf("  Failed to allocate a new action.\n\n");
+               return NULL;
+       }
+       memset(action, 0, sizeof(*action));
+       /* set the actions kind and id */
+       action->kind = kind;
+       action->id = action_counter++;
+       action->name = name;
+       action->max_node_aiid = -1;
+       action->max_edge_aiid = -1;
+       action->max_repl_node_aiid = -1;
+       action->max_repl_edge_aiid = -1;
+
+       LC_INIT_LIST_HEAD(& action->negatives);
+       LC_INIT_LIST_HEAD(& action->listed_conditions);
+       LC_INIT_LIST_HEAD(& action->listed_evals);
+
+
+       /* allocate this actions pattern graph */
+       action->pattern = (ext_grs_graph_t *)
+               obstack_alloc(&obst, sizeof(*(action->pattern)));
+       if (action->pattern == NULL) {
+               printf("module ext/grs: internal ERROR in function ext_grs_new_action()\n");
+               printf("  Failed to allocate a pattern graph for the new action.\n\n");
+               obstack_free(&obst, action);
+               return NULL;
+       }
+       init_graph(action->pattern, action, ext_grs_k_pattern);
+
+       /* if action is a rule, allocate a replacemant graph */
+       if (kind == ext_grs_k_rule) {
+               action->replacement = (ext_grs_graph_t *)
+                       obstack_alloc(&obst, sizeof(*(action->replacement)));
+               if (action->replacement == NULL) {
+                       printf("module ext/grs: internal ERROR in function ext_grs_new_action()\n");
+                       printf("  Failed to allocate a replacement graph for the new action.\n\n");
+                       obstack_free(&obst, action);
+                       return NULL;
+               }
+               init_graph(action->replacement, action, ext_grs_k_replacement);
+       }
+
+       action->kept_elems = lc_pset_new(ptr_map_cmp_func, 256);
+
+       return action;
+}
+
+/** get the kind of an action */
+ext_grs_action_kind_t ext_grs_act_get_kind(ext_grs_action_t *act) {
+       return act->kind;
+}
+
+/** impose a new negative graph pattern on the given action */
+ext_grs_graph_t *ext_grs_act_impose_negative(ext_grs_action_t *action) {
+
+       ext_grs_graph_t *negative;
+
+       /* if action is already mature no further changes are allowed */
+       if (action->mature) return NULL;
+
+       /* create new graph */
+       negative = (ext_grs_graph_t *) obstack_alloc(&obst, sizeof(*negative));
+       if (negative == NULL) {
+               printf("module ext/grs: ERROR in function ext_grs_act_impose_negative()\n");
+               printf("  failed to allocate a new action!\n");
+               return NULL;
+       }
+       init_graph(negative, action, ext_grs_k_negative);
+
+       /* store the new graph in the given action
+        * as a negative pattern graph */
+       lc_list_add(& negative->negative_list, & action->negatives);
+
+       return negative;
+}
+
+
+/** get the pattern graph of an action */
+ext_grs_graph_t *ext_grs_act_get_pattern(ext_grs_action_t *action) {
+       return action->pattern;
+}
+
+/** get the replacement graph of an action */
+ext_grs_graph_t *ext_grs_act_get_replacement(ext_grs_action_t *action) {
+
+       if (action->kind == ext_grs_k_rule) {
+               assert (action->replacement->kind == ext_grs_k_replacement &&
+                       "replacement graph has wrong kind");
+               return action->replacement;
+       }
+
+       /* if action is no rule, no replacement can be returned */
+       return NULL;
+}
+
+/** add a node to a given pattern graph */
+ext_grs_node_t *ext_grs_act_add_node(
+       ext_grs_graph_t *graph, char *name, ir_op *op, ir_mode *mode, int id)
+{
+       ext_grs_node_t *new_node;
+
+       if (!graph) {
+               printf("module ext/grs: ERROR in function ext_grs_add_node()\n");
+               printf("  Given graph was NULL!\n");
+               return NULL;
+       }
+       if (!name) {
+               printf("module ext/grs: ERROR in function ext_grs_add_node()\n");
+               printf("  Given name was NULL!\n");
+               return NULL;
+       }
+       if (!op) {
+               printf("module ext/grs: ERROR in function ext_grs_add_node()\n");
+               printf("  Given op was NULL!\n");
+               return NULL;
+       }
+       if (!mode) {
+               printf("module ext/grs: ERROR in function ext_grs_add_node()\n");
+               printf("  Given mode was NULL!\n");
+               return NULL;
+       }
+       if (id < 0) {
+               printf("module ext/grs: ERROR in function ext_grs_add_node()\n");
+               printf("  Negative node id was given.\n");
+               return NULL;
+       }
+       if (graph->action->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_add_node()\n");
+               printf("  Given graph belongs to a mature action.\n");
+               return NULL;
+       }
+
+       new_node = obstack_alloc(&obst, sizeof(*new_node));
+       memset(new_node, 0, sizeof(*new_node));
+
+       new_node->kind = ext_grs_k_node;
+       new_node->graph = graph;
+       new_node->name = name;
+       new_node->mode = mode;
+       new_node->op = op;
+       new_node->aiid = id;
+       new_node->related_node = NULL;
+       LC_INIT_LIST_HEAD(& new_node->edges[ext_grs_in]);
+       LC_INIT_LIST_HEAD(& new_node->edges[ext_grs_out]);
+
+       /* add node to the graph */
+       graph->n_nodes++;
+       lc_list_add(& new_node->node_list, & graph->nodes);
+
+       /* add node to the graphs action...? */
+       /* ...this is done by the the mature function when
+        * pseudo nodes and edges are created! */
+
+       if (graph->kind == ext_grs_k_replacement) {
+               graph->action->max_repl_node_aiid = MAX(id, graph->action->max_repl_node_aiid);
+       }
+       else {
+               assert((graph->kind == ext_grs_k_pattern || graph->kind == ext_grs_k_negative)
+                       && "given graph has invalid kind");
+               graph->action->max_node_aiid = MAX(id, graph->action->max_node_aiid);
+       }
+
+       return new_node;
+}
+
+ext_grs_node_t *ext_grs_act_add_related_node(ext_grs_graph_t *graph,
+                char *name, ir_op *op, ir_mode *mode, int id, ext_grs_node_t *positive_node)
+{
+       ext_grs_node_t *added_node = ext_grs_act_add_node(graph, name, op, mode, id);
+       ext_grs_act_relate_neg_node(positive_node, added_node);
+       return(added_node);
+}
+
+ext_grs_node_t *ext_grs_act_add_node_to_keep(ext_grs_graph_t *graph,
+                                                                                        char *name, ir_op *op, ir_mode *mode, int id, ext_grs_node_t *pattern_node)
+{
+       ext_grs_node_t *added_node = ext_grs_act_add_node(graph, name, op, mode, id);
+       ext_grs_act_announce_kept_node(pattern_node, added_node);
+       return(added_node);
+}
+
+
+/** add an edge to a given pattern graph */
+ext_grs_edge_t *ext_grs_act_add_edge(ext_grs_graph_t *graph,
+       char *name, int pos, ext_grs_node_t *arg, ext_grs_node_t *func, int id)
+{
+       ext_grs_edge_t *new_edge;
+
+       if (!graph) {
+               printf("module ext/grs: ERROR in function ext_grs_add_edge()\n");
+               printf("  Given graph was NULL.\n\n");
+               return NULL;
+       }
+       if (!name) {
+               printf("module ext/grs: ERROR in function ext_grs_add_edge()\n");
+               printf("  Given name was NULL.\n\n");
+               return NULL;
+       }
+       if (!arg) {
+               printf("module ext/grs: ERROR in function ext_grs_add_edge()\n");
+               printf("  Given argument node was NULL.\n\n");
+               return NULL;
+       }
+       if (!func) {
+               printf("module ext/grs: ERROR in function ext_grs_add_edge()\n");
+               printf("  Given function node was NULL.\n\n");
+               return NULL;
+       }
+       if (id < 0) {
+               printf("module ext/grs: ERROR in function ext_grs_add_edge()\n");
+               printf("  Given edge id was negative.\n\n");
+               return NULL;
+       }
+       if (graph->action->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_add_edge()\n");
+               printf("  Tried to add an edge to a graph of a mature action.\n\n");
+               return NULL;
+       }
+
+       if (func->op == op_Bad) {
+               printf("module ext/grs: WARNING in function ext_grs_add_edge()\n");
+               printf("  Added an incoming edge to a Bad node, this leads\n");
+               printf("  to a malformed graph.\n\n");
+       }
+
+
+       new_edge = obstack_alloc(&obst, sizeof(*new_edge));
+       memset(new_edge, 0, sizeof(*new_edge));
+
+       new_edge->kind = ext_grs_k_edge;
+       new_edge->graph = graph;
+       new_edge->name = name;
+       new_edge->pos = pos;
+       new_edge->func = func;
+       new_edge->arg = arg;
+       new_edge->aiid = id;
+       new_edge->related_edge = 0;
+
+       /* add edge to the graph */
+       graph->n_edges++;
+       lc_list_add(& new_edge->edge_list, & graph->edges);
+
+       /* add edge to tgt- and src-nodes in and out lists */
+       lc_list_add(&new_edge->list[ext_grs_in], & new_edge->func->edges[ext_grs_in]);
+       lc_list_add(&new_edge->list[ext_grs_out], & new_edge->arg->edges[ext_grs_out]);
+
+       /* add edge to the graphs action...? */
+       /* ...this is done by the the mature function when
+        * pseudo nodes and edges are created! */
+
+       if (graph->kind == ext_grs_k_replacement) {
+               graph->action->max_repl_edge_aiid = MAX(id, graph->action->max_repl_edge_aiid);
+       }
+       else {
+               assert((graph->kind == ext_grs_k_pattern || graph->kind == ext_grs_k_negative)
+                       && "given graph has invalid kind");
+               graph->action->max_edge_aiid = MAX(id, graph->action->max_edge_aiid);
+       }
+
+       return new_edge;
+}
+
+ext_grs_edge_t *ext_grs_act_add_related_edge(ext_grs_graph_t *graph,
+                                                        char *name, int pos, ext_grs_node_t *arg, ext_grs_node_t *func, int id, ext_grs_edge_t *positive_edge)
+{
+       ext_grs_edge_t *added_edge = ext_grs_act_add_edge(graph, name, pos, arg, func, id);
+       ext_grs_act_relate_neg_edge(positive_edge, added_edge);
+       return(added_edge);
+}
+
+ext_grs_edge_t *ext_grs_act_add_edge_to_keep(ext_grs_graph_t *graph,
+                                                                                        char *name, int pos, ext_grs_node_t *arg, ext_grs_node_t *func, int id, ext_grs_edge_t *pattern_edge)
+{
+       ext_grs_edge_t *added_edge = ext_grs_act_add_edge(graph, name, pos, arg, func, id);
+       ext_grs_act_announce_kept_edge(pattern_edge, added_edge);
+       return(added_edge);
+}
+
+/** mature an action, it is not possible to make any
+ *  changes to this actions pattern afterwards */
+
+int ext_grs_act_mature(ext_grs_action_t *action) {
+
+       int i;
+       lc_list_t *pos, *pos1;
+
+       int n_nodes = 0;
+       int n_edges = 0;
+       int n_neg_nodes = 0;
+       int n_neg_edges = 0;
+       int n_pseudo_nodes = 0;
+       int n_pseudo_edges = 0;
+
+
+       if (action->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+               printf("  given action is already mature!\n");
+               return 0;
+       }
+
+/* ................ 1 ................................................. */
+
+       /* compute the overall number of real nodes and negative nodes */
+       n_nodes = action->pattern->n_nodes;
+       lc_list_for_each(pos, &action->negatives) {
+               ext_grs_graph_t *neg =
+                       lc_list_entry(pos, ext_grs_graph_t, negative_list);
+               n_neg_nodes += neg->n_nodes;
+       }
+       /* compute the overall number of real edges and negative edges */
+       n_edges = action->pattern->n_edges;
+       lc_list_for_each(pos, &action->negatives) {
+               ext_grs_graph_t *neg =
+                       lc_list_entry(pos, ext_grs_graph_t, negative_list);
+               n_neg_edges += neg->n_edges;
+       }
+
+       /* alloc space for real and negative nodes */
+       action->nodes =
+               obstack_alloc(&obst, (action->max_node_aiid+1) * sizeof(ext_grs_node_t));
+       memset(action->nodes, 0 , (action->max_node_aiid+1) * sizeof(ext_grs_node_t));
+       /* alloc space for real, negative and pseudo edges */
+       action->edges =
+               obstack_alloc(&obst,
+                       (action->max_edge_aiid+1 + n_nodes + n_neg_nodes + n_edges) * sizeof(ext_grs_edge_t));
+       memset(action->edges, 0,
+               (action->max_edge_aiid+1 + n_nodes + n_neg_nodes + n_edges) * sizeof(ext_grs_edge_t));
+
+
+/* ................ 2 ................................................. */
+       {
+               int ret = 0;
+               ret = import_graph_info(action, action->pattern);
+               if (!ret) return 0;
+       }
+       lc_list_for_each(pos, &action->negatives) {
+               int ret = 0;
+               ext_grs_graph_t *neg =
+                       lc_list_entry(pos, ext_grs_graph_t, negative_list);
+               ret = import_graph_info(action, neg);
+               if (!ret) return 0;
+       }
+
+/* ................ 3 ................................................. */
+
+       /* there's a pseudo edge for each node and a backward pseudo edge
+        * for each real and each negative edge */
+       n_pseudo_edges = n_nodes + n_edges + n_neg_edges;
+       n_pseudo_nodes = 0;
+
+       /* setup space for information about homomorphic node matching and about critical
+        * nodes and edges. A node or edge is critical when it multiple matching may be
+        * harmful for parallel rule application */
+       if (action->max_node_aiid >= 0) {
+               action->hom =
+                       obstack_alloc(&obst, (action->max_node_aiid+1) * sizeof(*(action->hom)));
+               action->node_critical = obstack_alloc(&obst,
+                       (action->max_node_aiid+1) * sizeof(*(action->node_critical)));
+       }
+       if (n_nodes > 0)
+               action->pattern_node_kept =
+                       obstack_alloc(&obst, (action->max_node_aiid+1) * sizeof(*action->pattern_node_kept));
+
+       for (i=0; i <= action->max_node_aiid; i++) {
+
+               action->hom[i] = obstack_alloc(
+                       &obst, (action->max_node_aiid+1) * sizeof(**(action->hom)));
+               memset(action->hom[i], 0,
+                       (action->max_node_aiid+1) * sizeof(*(action->hom[i])));
+
+               if (!action->nodes[i]) continue;
+
+               /* by default every node is critical (unless it can be
+                * proofen that it is not) */
+               action->node_critical[i] = 1;
+               /* by default no node is kept */
+               action->pattern_node_kept[i] = -1;
+       }
+
+       if (action->max_edge_aiid >= 0) {
+               action->edge_critical = obstack_alloc(&obst,
+                       (action->max_edge_aiid+1) * sizeof(*(action->edge_critical)));
+               action->pattern_edge_kept =
+                       obstack_alloc(&obst, (action->max_edge_aiid+1) * sizeof(*action->pattern_edge_kept));
+       }
+
+       for (i=0; i <= action->max_edge_aiid; i++) {
+               /* by default each node is critical (unless it can be
+                * proofen that it is not) */
+               action->edge_critical[i] = 1;
+
+               if (!action->edges[i]) continue;
+
+               /* by default no edge is kept */
+               action->pattern_edge_kept[i] = -1;
+       }
+
+
+       /* .................................... 4 .................................. */
+       set_up_condition_stuff(action);
+
+       action->n_nodes = n_nodes;
+       action->n_edges = n_edges;
+
+       action->n_neg_nodes = n_neg_nodes;
+       action->n_neg_edges = n_neg_edges;
+
+       action->n_pseudo_nodes = n_pseudo_nodes;
+       action->n_pseudo_edges = n_pseudo_edges;
+
+
+
+
+       /* if the action is of kind test, no replacement information has to be set up */
+       if (action->kind == ext_grs_k_test) {
+               /* set mature flag */
+               action->mature = 1;
+               return 1;
+       }
+
+
+
+
+       /* setup replacement information */
+
+       /* first: nodes */
+       if (action->max_repl_node_aiid >= 0) {
+               action->replacement_nodes = obstack_alloc(&obst,
+                       (action->max_repl_node_aiid+1) * sizeof(*action->replacement_nodes));
+               memset(action->replacement_nodes, 0,
+                       (action->max_repl_node_aiid+1) * sizeof(*action->replacement_nodes));
+               action->replacement_node_kept = obstack_alloc(&obst,
+                       (action->max_repl_node_aiid+1) * sizeof(*action->replacement_node_kept));
+       }
+       for (i = 0; i <= action->max_repl_node_aiid; i++)
+               /* by default ALL nodea are newly inserted */
+               action->replacement_node_kept[i] = -1;
+
+       lc_list_for_each(pos1, & action->replacement->nodes) {
+
+               ext_grs_node_t *node = lc_list_entry(pos1, ext_grs_node_t, node_list);
+
+               if (action->replacement_nodes[node->aiid] == NULL) {
+                       action->replacement_nodes[node->aiid] = node;
+               }
+               else {
+                       printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+                       printf("  Multiply assigned id of a replacement node encountered!\n\n");
+                       return 0;
+               }
+       }
+       action->n_replacement_nodes = action->replacement->n_nodes;
+
+       /* second: edges */
+       if (action->max_repl_edge_aiid >= 0) {
+               action->replacement_edges = obstack_alloc(&obst,
+                       (action->max_repl_edge_aiid+1) * sizeof(*action->replacement_edges));
+               memset(action->replacement_edges, 0,
+                       (action->max_repl_edge_aiid+1) * sizeof(*action->replacement_edges));
+               action->replacement_edge_kept = obstack_alloc(&obst,
+                       (action->max_repl_edge_aiid+1) * sizeof(*action->replacement_edge_kept));
+       }
+       /* iterate over all replace edges */
+       for (i = 0; i <= action->max_repl_edge_aiid; i++)
+               /* by default ALL nodes are newly inserted */
+               action->replacement_edge_kept[i] = -1;
+
+       lc_list_for_each(pos, & action->replacement->edges) {
+               ext_grs_edge_t *edge = lc_list_entry(pos, ext_grs_edge_t, edge_list);
+
+               if (action->replacement_edges[edge->aiid] == NULL) {
+                       action->replacement_edges[edge->aiid] = edge;
+               }
+               else {
+                       printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+                       printf("  Multiply assigned id of a replacement edge encountered!\n\n");
+                       return 0;
+               }
+       }
+       action->n_replacement_edges = action->replacement->n_edges;
+
+
+
+
+
+       /* setup information about the nodes and edges, which have to be kept by
+        * the rewriting step */
+       {
+               /* for this reason iterate over all pairs of nodes/edges stored in the ptr
+                *  to ptr map representing the association of pattern ans replacement elements */
+               ext_grs_ptr_map_entry_t *entry = lc_pset_first(action->kept_elems);
+               for ( ; entry; entry = lc_pset_next(action->kept_elems) ) {
+
+                       if (entry->kind == ext_grs_k_node) {
+
+                               ext_grs_node_t *n1 = (ext_grs_node_t *) entry->pre;
+                               ext_grs_node_t *n2 = (ext_grs_node_t *) entry->img;
+
+                               assert(n1->kind == ext_grs_k_node && n2->kind == ext_grs_k_node);
+                               action->pattern_node_kept[n1->aiid] = n2->aiid;
+                               action->replacement_node_kept[n2->aiid] = n1->aiid;
+                       }
+
+                       else if (entry->kind == ext_grs_k_edge) {
+
+                               ext_grs_edge_t *e1 = (ext_grs_edge_t *) entry->pre;
+                               ext_grs_edge_t *e2 = (ext_grs_edge_t *) entry->img;
+
+                               assert(e1->kind == ext_grs_k_edge && e2->kind == ext_grs_k_edge);
+                               action->pattern_edge_kept[e1->aiid] = e2->aiid;
+                               action->replacement_edge_kept[e2->aiid] = e1->aiid;
+                       }
+
+                       else assert(0 && "found an invalid entry in the ptr to ptr map");
+               }
+       }
+
+       /* for all replacement nodes count the number of incoming edges having
+        * no given position and not being associated with a pattern edge and
+        * having no position function. This
+        * number is stored in each replacement nodes and represents the number
+        * of edges to appended to the matched host nodes in array without a
+        * specific order.
+        */
+       for (i = 0; i <= action->max_repl_node_aiid; i++) {
+               ext_grs_node_t *node = action->replacement_nodes[i];
+
+               if (!node) continue;
+
+
+               node->n_append_edges = 0;
+               lc_list_for_each (pos, & node->edges[ext_grs_in]) {
+
+                       ext_grs_edge_t *in_edge = lc_list_entry(pos, ext_grs_edge_t, list[ext_grs_in]);
+                       assert(in_edge->aiid >= 0 && "invalid aiid encountered");
+
+                       if (in_edge->position_func) {
+
+                               if (in_edge->pos != ext_grs_NO_EDGE_POS) {
+                                       assert(in_edge->pos >= 0 && "bad edge position");
+                                       printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+                                       printf("  There is a position function associated with an edge,\n");
+                                       printf("  which has a given postion.\n\n");
+                                       return 0;
+                               }
+                               if (action->replacement_node_kept[in_edge->aiid] >= 0) {
+                                       printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+                                       printf("  There is a position function associated with an edge,\n");
+                                       printf("  which is not to be newly inserted but kept.\n\n");
+                                       return 0;
+                               }
+
+                       }
+                       else {
+
+                               if
+                               (
+                                       in_edge->pos == ext_grs_NO_EDGE_POS &&
+                                       action->replacement_edge_kept[in_edge->aiid] == -1
+                               )
+                               {
+                                       node->n_append_edges++;
+                               }
+
+                       }
+
+               }
+       }
+
+
+
+
+       /* ensure that there is no edge, which has to be preserved while the rewriting
+        * and is incident to a pattern node, which has to be removed and, if not,
+        * ensure that associated edges are incident to associated nodes */
+       lc_list_for_each(pos, & action->pattern->edges) {
+
+               ext_grs_edge_t *edge = lc_list_entry(pos, ext_grs_edge_t, edge_list);
+
+               if (
+                       edge->kind == ext_grs_k_edge &&
+                       action->pattern_edge_kept[edge->aiid] > -1
+               )
+               {
+                       if (action->pattern_node_kept[edge->func->aiid] == -1 ||
+                               action->pattern_node_kept[edge->arg->aiid] == -1)
+                       {
+                               printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+                               printf("  Action contains a pattern edge which is announced as to\n");
+                               printf("  be kept in rewrite steps, but this edge is incident to\n");
+                               printf("  a pattern node which must be deleted.\n\n");
+
+                               return 0;
+                       }
+                       else {
+                               ext_grs_edge_t *rpl_edge;
+                               ext_grs_node_t *rpl_arg_node, *rpl_func_node;
+
+                               assert(
+                                       action->pattern_node_kept[edge->func->aiid] > -1 &&
+                                       action->pattern_node_kept[edge->arg->aiid] > -1 &&
+                                       "there should be no entry less than -1");
+
+                               rpl_edge = action->replacement_edges[action->pattern_edge_kept[edge->aiid]];
+                               rpl_func_node =
+                                       action->replacement_nodes[action->pattern_node_kept[edge->func->aiid]];
+                               rpl_arg_node =
+                                       action->replacement_nodes[action->pattern_node_kept[edge->arg->aiid]];
+
+                               if (rpl_edge->func != rpl_func_node || rpl_edge->arg != rpl_arg_node) {
+                                       printf("module ext/grs: ERROR in function ext_grs_act_mature()\n");
+                                       printf("  Action contains a pattern edge which is announced as to\n");
+                                       printf("  be kept in rewrite steps, but at least one of the replacement\n");
+                                       printf("  nodes incident to the associated replacement edge is not\n");
+                                       printf("  associated with the respective pattern nodes.\n\n");
+
+                                       return 0;
+                               }
+                       }
+
+               }
+       }
+
+
+#if 0
+       /* prepare relation between pattern nodes and negative nodes by
+        * initializing with 0 which means that there is no relation yet */
+       action->neg_node_related = obstack_alloc(&obst,
+                       (action->max_node_aiid+1) * sizeof(*action->neg_node_related));
+       memset(action->neg_node_related, 0,
+                       (action->max_node_aiid+1) * sizeof(*action->neg_node_related));
+
+       action->neg_edge_related = obstack_alloc(&obst,
+                       (action->max_edge_aiid+1) * sizeof(*action->neg_edge_related));
+       memset(action->neg_edge_related, 0,
+                       (action->max_edge_aiid+1) * sizeof(*action->neg_edge_related));
+#endif
+
+
+       /* set mature flag */
+       action->mature = 1;
+
+       return 1;
+}
+
+
+/** get a pattern node by its name */
+ext_grs_node_t *ext_grs_act_get_node(ext_grs_action_t *action, char *name) {
+
+       ext_grs_node_t *node;
+       int i;
+
+       if (action->mature == 0) {
+               printf("module ext/grs: ERROR in function ext_grs_act_get_node()\n");
+               printf("  The given action is NOT mature!\n\n");
+               return NULL;
+       }
+
+       // Look for the name in the pattern node array
+       for(i = 0; i <= action->max_node_aiid; i++) {
+               node = action->nodes[i];
+               if(node)
+                       if ( strcmp(name, node->name) == 0 )
+                               return node;
+       }
+
+       // Look for the name in the replace node array
+       for(i = 0; i <= action->max_repl_node_aiid; i++) {
+               node = action->replacement_nodes[i];
+               if(node)
+                       if (strcmp(name, node->name) == 0)
+                               return node;
+       }
+
+       return NULL;
+}
+
+
+/** Same as ext_grs_act_get_node, but compares only the first n bytes of the node name */
+ext_grs_node_t *ext_grs_act_get_node_n(ext_grs_action_t *action, char *name, int n) {
+
+       ext_grs_node_t *node;
+       int i;
+
+       if (action->mature == 0) {
+               printf("module ext/grs: ERROR in function ext_grs_act_get_node()\n");
+               printf("  The given action is NOT mature!\n\n");
+               return NULL;
+       }
+
+       // Look for the name in the pattern node array
+       for(i = 0; i <= action->max_node_aiid; i++) {
+               node = action->nodes[i];
+               if(node)
+                       if ( strncmp(name, node->name, n) == 0 )
+                               return node;
+       }
+
+       // Look for the name in the replace node array
+       for(i = 0; i <= action->max_repl_node_aiid; i++) {
+               node = action->replacement_nodes[i];
+               if(node)
+                       if (strncmp(name, node->name, n) == 0)
+                               return node;
+       }
+
+       return NULL;
+}
+
+
+/** Get a pattern node aiid by its name. */
+int ext_grs_act_get_node_aiid(ext_grs_action_t *action, char *name)
+{
+       ext_grs_node_t *node = ext_grs_act_get_node(action, name);
+       if(node)
+               return(node->aiid);
+       else
+               return(-1);
+}
+
+/** Same as ext_grs_act_get_nodes_aiid, but compares only the first n bytes of the nodes name */
+int ext_grs_act_get_node_aiid_n(ext_grs_action_t *action, char *name, int n)
+{
+       ext_grs_node_t *node = ext_grs_act_get_node_n(action, name, n);
+       if(node)
+               return(node->aiid);
+       else
+               return(-1);
+}
+
+
+
+/** get a pattern edge by its name */
+ext_grs_edge_t *ext_grs_act_get_edge(ext_grs_action_t *action, char *name) {
+
+       ext_grs_edge_t *edge;
+       int i;
+
+       if (action->mature == 0) {
+               printf("module ext/grs: ERROR in function ext_grs_act_get_edge()\n");
+               printf("  The given action is NOT mature\n\n");
+               return NULL;
+       }
+
+       for(i = 0; i < action->n_edges; i++) {
+               edge = action->edges[i];
+               if ( strcmp(name, edge->name) == 0 )
+                       return edge;
+       }
+       return NULL;
+}
+
+
+/** allows homomorphic matching of two pattern nodes,
+ *  note that these two nodes MUST have the same op and mode
+ *  (including mode ANY) and belong tp the same acion
+ *  @returns zero if fails and nonzero otherwise
+ *  @note the action the given nodes belong to has to be mature */
+int ext_grs_act_allow_nodes_hom(ext_grs_node_t *n1, ext_grs_node_t *n2)
+{
+       ext_grs_action_t *act;
+
+       if (!n1 || !n2) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  NULL node(s) has/have been given.\n\n");
+               return 0;
+       }
+
+       assert(n1->graph && n2->graph && "every node should belong to a graph");
+       assert(n1->graph->action && n2->graph->action &&
+               "every graph should belong to an action");
+       act = n1->graph->action;
+
+       /* check wether the given nodes are not replacement nodes nodes */
+       if (
+               n1->graph->kind == ext_grs_k_replacement ||
+               n2->graph->kind == ext_grs_k_replacement
+       )
+       {
+               assert(n1->graph == act->replacement);
+               assert(n2->graph == act->replacement);
+
+               printf("module ext/grs: ERROR in function ext_grs_act_allow_nodes_hom()\n");
+               printf("  At least one given node belongs to a replacement graph.\n\n");
+               return 0;
+       }
+
+       /* check wether the given nodes belong to the given action */
+       if (n1->graph->action != n2->graph->action) {
+               printf("module ext/grs: ERROR in function ext_grs_act_allow_nodes_hom()\n");
+               printf("  Given nodes belong to different actions.\n\n");
+               return 0;
+       }
+       /* action has to be mature */
+       if (! act->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_act_allow_nodes_hom()\n");
+               printf("  Given action is not mature.\n\n");
+               return 0;
+       }
+       /* check wether the given nodes have the same firm op and firm mode */
+       if (n1->op != n2->op  ||  n1->mode != n2->mode) {
+               printf("module ext/grs: ERROR in function ext_grs_act_allow_nodes_hom()\n");
+               printf("  Given nodes have different Firm op and/or different Firm mode.\n\n");
+               return 0;
+       }
+       /* if the given pattern nodes are BOTH associated with replacement
+        * nodes, check wether the ops and modes of the replacement nodes are equal */
+       if (act->pattern_node_kept[n1->aiid] >= 0 && act->pattern_node_kept[n2->aiid] >= 0) {
+
+               ext_grs_node_t *rpl_n1, *rpl_n2;
+
+               assert(n1->graph->kind != ext_grs_k_negative &&
+                       "a negative node should not be marked as kept");
+               assert(n2->graph->kind != ext_grs_k_negative &&
+                       "a negative node should not be marked as kept");
+
+               rpl_n1 = act->replacement_nodes[act->pattern_node_kept[n1->aiid]];
+               rpl_n2 = act->replacement_nodes[act->pattern_node_kept[n2->aiid]];
+               if (rpl_n1->op != rpl_n2->op || rpl_n1->mode != rpl_n2->mode)
+               {
+                       printf("module ext/grs: ERROR in function ext_grs_act_allow_nodes_hom()\n");
+                       printf("  Given pattern nodes are assiciated with replacement nodes of\n");
+                       printf("  different op or mode, this may cause undefined behaviour of\n");
+                       printf("  the replacement when the nodes are matched homomorphic.\n\n");
+                       return 0;
+               }
+       }
+
+
+       /* allow homomorphic matching of the given node */
+       act->hom[n1->aiid][n2->aiid] = 1;
+
+       return 1;
+}
+
+
+int ext_grs_act_announce_kept_node(ext_grs_node_t *n1, ext_grs_node_t *n2)
+{
+       ext_grs_action_t *act;
+       ext_grs_ptr_map_entry_t *new_entry = obstack_alloc(&obst, sizeof(*new_entry));
+
+       if (! new_entry) {
+               printf("module ext/grs: Internal ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  Failed to allocate a new node pair representative.\n\n");
+               return 0;
+       }
+
+       if (!n1 || !n2) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  NULL node(s) has/have been given.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+
+       assert(n1->graph->action && n2->graph->action &&
+               "every graph should belong to an action");
+       act = n1->graph->action;
+
+       /* check wether the given nodes belong to the given action */
+       if (n1->graph->action != n2->graph->action) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  Given nodes belong to different actions.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+       /* action must not be mature */
+       if (act->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  Given action must not be mature.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+       /* check wether n1 belongs to pattern and n2 to the replacement graph */
+       if (n1->graph != act->pattern || n2->graph != act->replacement) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  A pattern node and a replacement node must be given.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       new_entry->kind = ext_grs_k_node;
+       new_entry->pre = n1;
+       new_entry->img = n2;
+
+       not_injective = 0;
+       multiple_entry = 0;
+       already_exists = 0;
+       lc_pset_insert(act->kept_elems, new_entry, LC_HASH_PTR(new_entry));
+
+       if (not_injective) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  The given replacement node has already been\n");
+               printf("  associated with another pattern node.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       if (multiple_entry) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  The given pattern node has already been\n");
+               printf("  associated with another replacement node.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       if (already_exists) {
+               printf("module ext/grs: WARNING in function ext_grs_act_announce_kept_node()\n");
+               printf("  The given association has already been announced.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       return 1;
+}
+
+int ext_grs_act_announce_kept_edge(ext_grs_edge_t *e1, ext_grs_edge_t *e2)
+{
+       ext_grs_action_t *act;
+       ext_grs_ptr_map_entry_t *new_entry = obstack_alloc(&obst, sizeof(*new_entry));
+
+       if (! new_entry) {
+               printf("module ext/grs: Internal ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  Failed to allocate a new edge pair representative.\n\n");
+               return 0;
+       }
+
+       if (!e1 || !e2) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_edge()\n");
+               printf("  NULL edge(s) has/have been given.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       if (!e1->graph || !e2->graph || !e1->graph->action || !e2->graph->action) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_edge()\n");
+               printf("  At least one of the given edges is corrupted.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       act = e1->graph->action;
+
+       /* check wether the given nodes belong to the given action */
+       if (e1->graph->action != e2->graph->action) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_edge()\n");
+               printf("  Given edges belong to different actions.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+       /* action has to be mature */
+       if (act->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_edge()\n");
+               printf("  Given action must not be mature.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+       /* check wether n1 belongs to pattern and n2 to the replacement graph */
+       if (e1->graph != act->pattern || e2->graph != act->replacement) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_edge()\n");
+               printf("  A pattern edge and a replacement edge must be given.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       if (e1->pos != e2->pos) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_edge()\n");
+               printf("  The pattern and the replacemnt edge must have the same position OR\n");
+               printf("  both no position at all.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       new_entry->kind = ext_grs_k_edge;
+       new_entry->pre = e1;
+       new_entry->img = e2;
+
+       not_injective = 0;
+       multiple_entry = 0;
+       already_exists = 0;
+       lc_pset_insert(act->kept_elems, new_entry, LC_HASH_PTR(new_entry));
+
+       if (not_injective) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  The given replacement node has already been\n");
+               printf("  associated with another pattern node.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       if (multiple_entry) {
+               printf("module ext/grs: ERROR in function ext_grs_act_announce_kept_node()\n");
+               printf("  The given pattern node has already been\n");
+               printf("  associated with another replacement node.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       if (already_exists) {
+               printf("module ext/grs: WARNING in function ext_grs_act_announce_kept_node()\n");
+               printf("  The given association has already been announced.\n\n");
+               obstack_free(&obst, new_entry);
+               return 0;
+       }
+
+       return 1;
+}
+
+int ext_grs_act_relate_neg_node(ext_grs_node_t *pat_node, ext_grs_node_t *neg_node) {
+
+       if (pat_node->graph->action != neg_node->graph->action) {
+               printf("module ext/grs: ERROR in function ext_grs_act_relate_neg_node()\n");
+               printf("  The given nodes do not belong to the same action.\n\n");
+               return 0;
+       }
+
+       if (pat_node->graph->kind != ext_grs_k_pattern) {
+               printf("module ext/grs: ERROR in function ext_grs_act_relate_neg_node()\n");
+               printf("  The given pattern node does not belong to a pattern graph.\n\n");
+               return 0;
+       }
+
+       if (neg_node->graph->kind != ext_grs_k_negative) {
+               printf("module ext/grs: ERROR in function ext_grs_act_relate_neg_node()\n");
+               printf("  The given negative node does not belong to a negative pattern graph.\n\n");
+               return 0;
+       }
+
+       neg_node->related_node = pat_node;
+       return(1);
+}
+
+int ext_grs_act_relate_neg_edge(ext_grs_edge_t *pat_edge, ext_grs_edge_t *neg_edge) {
+
+       if (pat_edge->graph->action != neg_edge->graph->action) {
+               printf("module ext/grs: ERROR in function ext_grs_act_relate_neg_edge()\n");
+               printf("  The given edges do not belong to the same action.\n\n");
+               return 0;
+       }
+
+       if (pat_edge->graph->kind != ext_grs_k_pattern) {
+               printf("module ext/grs: ERROR in function ext_grs_act_relate_neg_edge()\n");
+               printf("  The given pattern edge does not belong to a pattern graph.\n\n");
+               return 0;
+       }
+
+       if (neg_edge->graph->kind != ext_grs_k_negative) {
+               printf("module ext/grs: ERROR in function ext_grs_act_relate_neg_edge()\n");
+               printf("  The given negative edge does not belong to a negative pattern graph.\n\n");
+               return 0;
+       }
+
+       neg_edge->related_edge = pat_edge;
+       return(1);
+}
+
+
+
+int ext_grs_act_register_condition(
+               ext_grs_condition_func_t func,
+               ext_grs_graph_t *graph,
+               int n_nodes, ext_grs_node_t **nodes,
+               int n_edges, ext_grs_edge_t **edges)
+{
+       int i;
+       ext_grs_cond_descr_t *cond_descr;
+       ext_grs_node_t **nodes_copied = obstack_alloc(&obst, n_nodes * sizeof(*nodes_copied));
+       ext_grs_edge_t **edges_copied = obstack_alloc(&obst, n_edges * sizeof(*edges_copied));
+
+       if (!func) {
+               printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+               printf("  The given condition function was NULL.\n\n");
+               return 0;
+       }
+
+       if (!graph) {
+               printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+               printf("  The given (pattern or negative graph) was NULL.\n\n");
+               return 0;
+       }
+
+       if (graph->action->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+               printf("  The given action is already mature, no condition registered.\n\n");
+               return 0;
+       }
+
+       /* check whether the given nodes and edges are really nodes and edges, AND check
+        * whether these nodes and edges all belong to the given action */
+       for (i = 0; i < n_nodes; i++) {
+
+               if (!nodes[i]) {
+                       printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+                       printf("  A given node was NULL.\n\n");
+                       return 0;
+               }
+               if (nodes[i]->kind != ext_grs_k_node) {
+                       printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+                       printf("  A given node was not a valid node.\n\n");
+                       return 0;
+               }
+               if (nodes[i]->graph->action != graph->action) {
+                       printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+                       printf("  A given node belongs to an action different from the one of the given\n");
+                       printf("  (pattern or negative) graph.\n\n");
+                       return 0;
+               }
+
+               nodes_copied[i] = nodes[i];
+       }
+       for (i = 0; i < n_edges; i++) {
+
+               if (!edges[i]) {
+                       printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+                       printf("  A given edge was NULL.\n\n");
+                       return 0;
+               }
+               if (edges[i]->kind != ext_grs_k_edge) {
+                       printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+                       printf("  A given edge was not a valid edge.\n\n");
+                       return 0;
+               }
+               if (edges[i]->graph->action != graph->action) {
+                       printf("module ext/grs: ERROR in function ext_grs_act_register_condition()\n");
+                       printf("  A given edge belongs to an action different from one of the given\n");
+                       printf("  (pattern or negative) graph.\n\n");
+                       return 0;
+               }
+
+               edges_copied[i] = edges[i];
+       }
+
+       /* allocate space for a condition descriptor */
+       cond_descr = obstack_alloc(&obst, sizeof(*cond_descr));
+       memset(cond_descr, 0, sizeof(cond_descr));
+
+       /* init the condition descriptor */
+       cond_descr->graph = graph;
+       cond_descr->condition = func;
+
+       cond_descr->n_nodes = n_nodes;
+       cond_descr->nodes = nodes_copied;
+       cond_descr->n_edges = n_edges;
+       cond_descr->edges = edges_copied;
+
+       /* add the condition descriptor to the list */
+       lc_list_add(&cond_descr->condition_list, & graph->action->listed_conditions);
+       /* increment the number of conditions */
+       graph->n_conditions++;
+       graph->action->n_conditions++; // AS
+       return 1;
+}
+
+
+int ext_grs_act_register_eval(ext_grs_action_t *action,
+               ext_grs_eval_in_func_t in_func, ext_grs_eval_out_func_t out_func)
+{
+       ext_grs_eval_descr_t *eval_descr;
+
+       /*if (!in_func) {
+               printf("module ext/grs: ERROR in function ext_grs_act_register_eval()\n");
+               printf("  The given eval-in function function was NULL.\n\n");
+               return 0;
+       }
+       if (!out_func) {
+               printf("module ext/grs: ERROR in function ext_grs_act_register_eval()\n");
+               printf("  The given eval-out function function was NULL.\n\n");
+               return 0;
+       }*/
+       if (action->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_act_register_eval_out_func()\n");
+               printf("  The given action is already mature, no eval function registered.\n\n");
+               return 0;
+       }
+
+       eval_descr = obstack_alloc(&obst, sizeof(*eval_descr));
+       memset(eval_descr, 0, sizeof(*eval_descr));
+       eval_descr->eval_in = in_func;
+       eval_descr->eval_out = out_func;
+       eval_descr->data = NULL;
+       lc_list_add_tail(& eval_descr->eval_list, & action->listed_evals);
+       return 1;
+}
+
+
+
+int ext_grs_act_set_op_condition(
+       ext_grs_node_t *node, ext_grs_op_condition_func_t func)
+{
+       if (!node) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_op_condition()\n");
+               printf("  The given node was NULL.\n\n");
+               return 0;
+       }
+       if (!func) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_op_condition()\n");
+               printf("  The given op condition function was NULL.\n\n");
+               return 0;
+       }
+
+       node->op_condition = func;
+       return 1;
+}
+
+int ext_grs_act_set_mode_condition(
+               ext_grs_node_t *node, ext_grs_mode_condition_func_t func)
+{
+       if (!node) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_mode_condition()\n");
+               printf("  The given node was NULL.\n\n");
+               return 0;
+       }
+       if (!func) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_mode_condition()\n");
+               printf("  The given mode condition function was NULL.\n\n");
+               return 0;
+       }
+
+       node->mode_condition = func;
+       return 1;
+}
+
+int ext_grs_act_set_pos_func(ext_grs_edge_t *edge, ext_grs_edge_pos_func_t func)
+{
+       if (!edge) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_pos_func()\n");
+               printf("  The given edge was NULL.\n\n");
+               return 0;
+       }
+       if (!edge) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_pos_func()\n");
+               printf("  The given position function was NULL.\n\n");
+               return 0;
+       }
+       assert(edge->graph && "every edge should have a graph");
+       if (edge->graph->kind != ext_grs_k_replacement) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_pos_func()\n");
+               printf("  The given edge belongs to a graph, which is not a replacement graph.\n\n");
+               return 0;
+       }
+       assert(edge->graph->action && "every graph should have an action");
+       if (edge->graph->action->mature) {
+               printf("module ext/grs: ERROR in function ext_grs_act_set_pos_func()\n");
+               printf("  The given edge belongs to an action, which is already mature.\n\n");
+               return 0;
+       }
+
+       edge->position_func = func;
+       return 1;
+}
+
+
+/* Initilize the action part of the exr/grs module of the libfirm.
+ * This is an internal function. */
+void _ext_grs_act_init() {
+       /* init obstack if necesarry */
+       if (obst_init == 0) {
+               obstack_init(&obst);
+       }
+       obst_init = 1;
+}
+
+/* Finalize the action part of the exr/grs module of the libfirm.
+ * This is an internal function */
+void _ext_grs_act_finalize() {
+
+       /* finalize the action obstack */
+       obstack_free(&obst, NULL);
+       obstack_finish(&obst);
+}

diff --git a/ir/be/grgen/action.h b/ir/be/grgen/action.h
new file mode 100644 (file)
index 0000000..dd11485
--- /dev/null
+++ b/ir/be/grgen/action.h
@@ -0,0 +1,364 @@
+#ifndef _EXT_GRS_ACTION_H_
+#define _EXT_GRS_ACTION_H_
+
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/action.h
+ * Purpose:     provides an interface for the creation of actions
+ *                             (i.e. rewriting rules and patterns to be found without
+ *              performing a rewriting step)
+ * Author:      Veit Batz
+ * Modified by: Andreas Schoesser
+ * Created:            29. August 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+
+/** represents a node in a grs action */
+typedef struct _ext_grs_node_t ext_grs_node_t;
+
+/** represents an edge in a grs action */
+typedef struct _ext_grs_edge_t ext_grs_edge_t;
+
+/** represents a pattern, negative or replacement graph */
+typedef struct _ext_grs_graph_t ext_grs_graph_t;
+
+/** An action the grs can perform. Possible kinds of actions are rules
+ * and tests. A rule describes the replacement of pattern graphs by a
+ * replacement graph, a test only describes the lookup for occurences of
+ * the pattern graphs, where it is not intended to perform a replacement */
+typedef struct _ext_grs_action_t ext_grs_action_t;
+
+
+
+
+/** the kind of a grs action */
+typedef enum
+{
+       ext_grs_k_test, /**< a "test" represents a lookup for a given pattern */
+       ext_grs_k_rule /**< a "rule" represents a graph rewriting step */
+}
+ext_grs_action_kind_t;
+
+/** A condition function to be invoked by the matcher. If the condition
+ *  represented by the function does not hold, the current potential match
+ *  will be rejected by the matcher.
+ *
+ *  @param node_map    the current node map during the matching process,
+ *                                     maps the user defined node ids to host graph nodes
+ *  @param edge_map    the current edge map during the matching process,
+ *                                     maps the user defined edge ids to host graph edges
+ *
+ *  @return Return non zero if the condition holds and zero if it does not.
+ *  @note The functions ext_grs_get_pattern_nodes_image() and
+ *        ext_grs_get_pattern_edges_image() provide the images
+ *        of pattern nodes and edges under the current match. */
+typedef int (* ext_grs_condition_func_t)
+       (ir_node **node_map, const ir_edge_t **edge_map);
+
+/** A function ptr to be invoked on inserting new edges during the
+ *  rewrite step. The function pointed to is supposed to compute the
+ *  position of the newly inserted edge.
+ *
+ *  @param edge                the replacement edge, the position of which is computed
+ *  @param node_map The node map of the match, which is used in the
+ *                                     current rewrite.
+ *  @param edge_map    The edge map of the match, which is used in the
+ *                                     current rewrite.
+ *
+ *  @return The position of a newly inserted edge, i.e., a non negative
+ *             integer or ext_grs_NO_EDGE_POS. If the result equals
+ *             ext_grs_NO_EDGE_POS the edge is appended to the exisiting edge
+ *             array.
+ *
+ *  @note The functions ext_grs_get_pattern_nodes_image() and
+ *        ext_grs_get_pattern_edges_image() provide the images
+ *        of pattern nodes and edges under the current match. */
+typedef int (* ext_grs_edge_pos_func_t)
+       (ext_grs_edge_t *edge, ir_node **node_map, const ir_edge_t **edge_map);
+
+/**
+ * A condition function to be invoked by the matcher. If the function
+ * representing the condition does not hold for the given op, the matching
+ * of a node with this op is prohibited
+ *
+ * @param op   the op to be checked
+ * @return nonzero if the condition holds, zero otherwise
+ * */
+typedef int (* ext_grs_op_condition_func_t) (ir_op *op);
+
+/**
+ * A condition function to be invoked by the matcher. If the function
+ * representing the condition does not hold for the given mode, the matching
+ * of a node with this mode is prohibited
+ *
+ * @param mode the mode to be checked
+ * @return nonzero if the condition holds, zero otherwise
+ * */
+typedef int (* ext_grs_mode_condition_func_t) (ir_mode *mode);
+
+/**
+ * A function representing the in-part of a computation, which
+ * has to be evaluated BEFORE performing a graph rewrite step. Every
+ * such function is associated with a function of type
+ * ext_grs_eval_out_func_t representing the out-part of the computation.
+ *
+ *  @param pat_node_map        the node map of the match, the rewriting is performed with.
+ *  @param pat_edge_map        the edge map of the match, the rewriting is performed with.
+ *
+ *     @returns        A ptr to some user defined data. The ptr returned will
+ *                             passed as input data to the respective eval-out function.
+ */
+typedef void* (* ext_grs_eval_in_func_t) (
+       ir_node **pat_node_map, const ir_edge_t **pat_edge_map);
+
+/**
+ * A function representing the out-part of a computation, which
+ * has to be evaluated AFTER performing a graph rewrite step. Every
+ * such function is associated with a function of type
+ * ext_grs_eval_in_func_t representing the in-part of the computation.
+ *
+ *  @param rpl_node_map                the node map of the match, the rewriting is performed with.
+ *  @param rpl_edge_map                the edge map of the match, the rewriting is performed with.
+ *  @param pat_node_map                the node map of the match, the rewriting is performed with.
+ *  @param data                                the pointer of user defined data returned by the respective
+ *                                                     eval-in function
+ */
+typedef void (* ext_grs_eval_out_func_t) (
+       ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map,
+       ir_node **pat_node_map, void *data);
+
+
+
+/** an invalid node or edge index, this is needed for negative
+ *  nodes and edges which are NOT matched */
+#define ext_grs_EDGE_NODE_INDEX_INVALID -99
+/** an invalid edge position */
+#define ext_grs_NO_EDGE_POS -99
+
+
+
+
+
+/** Create a new graph action of the given kind. */
+ext_grs_action_t *ext_grs_new_action(ext_grs_action_kind_t kind, char *name);
+
+/** Get the kind of an action. */
+ext_grs_action_kind_t ext_grs_act_get_kind(ext_grs_action_t *act);
+
+/** Impose a new negative graph pattern on the given action.
+ *  @note The action must NOT be mature. */
+ext_grs_graph_t *ext_grs_act_impose_negative(ext_grs_action_t *action);
+
+/** Get the pattern graph of an action. */
+ext_grs_graph_t *ext_grs_act_get_pattern(ext_grs_action_t *action);
+
+/** Get the replacement graph of a rule action. If the action is not
+ *  of kind rule NULL is returned instead.
+ */
+ext_grs_graph_t *ext_grs_act_get_replacement(ext_grs_action_t *action);
+
+/** add a new node to a given pattern graph of an unmature action
+ *  @param graph       the pattern, negative or replacement graph the node is added to
+ *  @param name                the new nodes name
+ *  @param op          the new nodes op
+ *  @param mode                the new nodes mode
+ *  @param id          the id of the new node
+ *
+ *  @returns           the new node
+ *
+ *  @note      the id has to be unique over the hole set of nodes of the pattern
+ *                     and all negative graphs of an action, and unique for the set of nodes
+ *                     of the replacement graph of an action.
+ */
+ext_grs_node_t *ext_grs_act_add_node(ext_grs_graph_t *graph,
+       char *name, ir_op *op, ir_mode *mode, int id);
+
+/** Add a new node to a negative pattern and relate it with a positive node */
+ext_grs_node_t *ext_grs_act_add_related_node(ext_grs_graph_t *graph,
+       char *name, ir_op *op, ir_mode *mode, int id, ext_grs_node_t *positive_node);
+
+/** Add a new node to the replacement pattern and announce to keep it in the host graph */
+ext_grs_node_t *ext_grs_act_add_node_to_keep(ext_grs_graph_t *graph,
+                                                                                        char *name, ir_op *op, ir_mode *mode, int id, ext_grs_node_t *pattern_node);
+
+/** Add a new edge to a given pattern graph of an UNmature action.
+ *  @param graph       the pattern, negative or replacement graph the node is added to
+ *  @param name                the new nodes name
+ *  @param arg         the new edges target node
+ *  @param func                the new edges source node
+ *  @param id          the id of the new edge
+ *
+ *  @returns           the new edge
+ *
+ *  @note      the id has to be unique over the hole set of edges of the pattern
+ *                     and all negative graphs of an action, and unique for the set of edges
+ *                     of the replacement graph of an action.
+ */
+ext_grs_edge_t *ext_grs_act_add_edge(ext_grs_graph_t *graph,
+       char *name, int pos, ext_grs_node_t *arg, ext_grs_node_t *func, int id);
+
+/** Add a new edge to a negative pattern and relate it with a positive edge */
+ext_grs_edge_t *ext_grs_act_add_related_edge(ext_grs_graph_t *graph,
+                                                        char *name, int pos, ext_grs_node_t *arg, ext_grs_node_t *func, int id, ext_grs_edge_t *positive_edge);
+
+/** Add a new edge to the replacement pattern and announce to keep it in the host graph */
+ext_grs_edge_t *ext_grs_act_add_edge_to_keep(ext_grs_graph_t *graph,
+                                                                                        char *name, int pos, ext_grs_node_t *arg, ext_grs_node_t *func, int id, ext_grs_edge_t *pattern_edge);
+
+/** Mature an action. It is not possible to make any
+ *  changes to this actions pattern afterwards (except allowing
+ *  the homomorphic matching of nodes).
+ *  @returns nonzero if succesful */
+int ext_grs_act_mature(ext_grs_action_t *action);
+
+/** Get a pattern node by its name. */
+ext_grs_node_t *ext_grs_act_get_node(ext_grs_action_t *action, char *name);
+
+/** Get a pattern node aiid by its name. */
+int ext_grs_act_get_node_aiid(ext_grs_action_t *action, char *name);
+int ext_grs_act_get_node_aiid_n(ext_grs_action_t *action, char *name, int n);
+
+/** Get a pattern edge by its name. */
+ext_grs_edge_t *ext_grs_act_get_edge(ext_grs_action_t *action, char *name);
+
+/** Allow homomorphic matching of two pattern nodes,
+ *  note that these two nodes MUST have the same op and mode
+ *  (including mode ANY) and belong tp the same acion
+ *  @returns zero if fails and nonzero otherwise
+ *  @note the action the given nodes belong to has to be mature */
+int ext_grs_act_allow_nodes_hom(ext_grs_node_t *n1, ext_grs_node_t *n2);
+
+/** Assocites a pattern node and a replacement node of a given rule-action
+ *  to be a node which is kept in the rewrting step.
+ *
+ *  @param e1  the pattern edge
+ *  @param e2  the replacement edge
+ *
+ *  @return zero if an error occured, nonzero otherwise
+ */
+int ext_grs_act_announce_kept_node(ext_grs_node_t *n1, ext_grs_node_t *n2);
+
+/** Assocites a pattern edge and a replacement edge of a given rule-action
+ *  to be an edge which is kept in the rewriting step. The two edges must
+ *  have the same position or both no position at all. Otherwise an error
+ *  will be reported.
+ *
+ *  @param e1  the pattern edge
+ *  @param e2  the replacement edge
+ *
+ *  @return zero if an error occurred, nonzero otherwise
+ *
+ *  @note if the replacement contains an edge without a valid position which is
+ *    NOT associated with a pattern edge, an error will occur while maturing the
+ *    respective action
+ */
+int ext_grs_act_announce_kept_edge(ext_grs_edge_t *e1, ext_grs_edge_t *e2);
+
+/** relate a negative node with a pattern node
+ *
+ *  @param pat_node    the pattern node
+ *  @param neg_node    the negative node
+ *
+ *  @return zero if an error occured, nonzero otherwise
+ *
+ *  @note      The pattern and the negative node must belong to the same action.
+ *                     Furthermore, the action has to be already mature.
+ */
+int ext_grs_act_relate_neg_node(ext_grs_node_t *pat_node, ext_grs_node_t *neg_node);
+
+/** relate a negative edge with a pattern edge
+ *
+ *  @param pat_edge    the pattern node
+ *  @param neg_edge    the negative node
+ *
+ *  @return zero if an error occured, nonzero otherwise
+ *
+ *  @note      The pattern and the negative edge must belong to the same action.
+ *                     Furthermore, the action has to be already mature.
+ *
+ */
+int ext_grs_act_relate_neg_edge(ext_grs_edge_t *pat_edge, ext_grs_edge_t *neg_edge);
+
+/** Sets the position function of a replacement edge. After rewriting the
+ *  host edge corresponding to that replace edge gets the position computed
+ *  by the position function.
+ *
+ *  @param edge        the replacement edge
+ *  @param func        the function computing the edge pos
+ *
+ *  @return zero if an error occured, nonzero otherwise
+ *
+ *  @note      Fails if the given edge is not a replace edge or the
+ *                     the action the given edge belongs to is already mature.
+ */
+int ext_grs_act_set_pos_func(ext_grs_edge_t *edge, ext_grs_edge_pos_func_t func);
+
+/** Sets the op condition function of a (pattern or negative) node.
+ *  The function checks wether nodes of certain subops may be matched
+ *  with the given (pattern or negative) node or not
+ *
+ *  @param node        a (pattern or negative) node
+ *  @param func        the op condition function
+ *
+ *  @return zero if an error occured, nonzero otherwise
+ */
+int ext_grs_act_set_op_condition(
+               ext_grs_node_t *node, ext_grs_op_condition_func_t func);
+
+/** Registers a mode condition function of a (pattern or negative) node.
+ *  The function checks wether nodes of certain modes may be matched
+ *  with the given (pattern or negative) node or not
+ *
+ *  @param node        a (pattern or negative) node
+ *  @param func        the mode condition function
+ *
+ *  @return zero if an error occured, nonzero otherwise
+ */
+int ext_grs_act_set_mode_condition_func(
+               ext_grs_node_t *node, ext_grs_mode_condition_func_t func);
+
+/** Registers a condition function with some pattern or
+ *  negative nodes of an action.
+ *
+ *  @param func                the function representing the condition
+ *  @param graph       the (pattern or negative) graph the given condition
+ *                                     function is associated with
+ *  @param n_nodes     the number of nodes involved in the condition
+ *  @param nodes    the array of involved nodes
+ *  @param n_edges     the number of edges involved in the condition
+ *  @param nodes    the array of involved edges
+ *
+ *  @return zero if an error occured, nonzero otherwise
+
+ *  @note      The given action must NOT be mature!
+ */
+int ext_grs_act_register_condition(
+               ext_grs_condition_func_t func,
+               ext_grs_graph_t *graph,
+               int n_nodes, ext_grs_node_t **nodes,
+               int n_edges, ext_grs_edge_t **edges);
+
+/** Registers a pair of functions representing a computation,
+ *  which shall be evaluated on a rewrite. The in-part is
+ *  computed BEFORE the transformation of the host graph,
+ *  the out-part is computed AFTER that.
+ *
+ *  @param action      the action the eval-out function is associated with
+ *  @param in_func     the function representing the computations in-part
+ *  @param out_func    the function representing the computations out-part
+ *
+ *  @return zero if an error occurred, nonzero otherwise
+ *
+ *  @note      The given action must NOT be mature!
+ */
+int ext_grs_act_register_eval(ext_grs_action_t *action,
+               ext_grs_eval_in_func_t in_func, ext_grs_eval_out_func_t out_func);
+
+
+
+
+#endif /*_EXT_GRS_ACTION_H_*/

diff --git a/ir/be/grgen/action_t.h b/ir/be/grgen/action_t.h
new file mode 100644 (file)
index 0000000..6ba77d0
--- /dev/null
+++ b/ir/be/grgen/action_t.h
@@ -0,0 +1,358 @@
+#ifndef _EXT_GRS_ACTION_T_H_
+#define _EXT_GRS_ACTION_T_H_
+
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/action_t.h
+ * Purpose:     provides an internal interface for the creation of actions
+ *                             (i.e. rewriting rules and patterns to be found without
+ *              performing a rewriting step)
+ * Author:      Veit Batz
+ * Created:            29. August 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+#include <libcore/lc_bitset.h>
+
+#include "common_t.h"
+#include "action.h"
+
+
+
+
+
+
+/** the kind of a graph elem (node or edge) */
+typedef enum {
+       /** a graph node */
+       ext_grs_k_node,
+       /** a graph edge */
+       ext_grs_k_edge,
+       /** a pseudo node  */
+       ext_grs_k_pseudo_node,
+       /** a pseudo edge  */
+       ext_grs_k_pseudo_edge
+} ext_grs_elem_kind_t;
+
+
+typedef double ext_grs_edge_cost_t;
+
+
+
+/** represents a node in a grs rule */
+struct _ext_grs_node_t
+{
+       ext_grs_elem_kind_t kind; /** mus be ext_grs_k_node or ext_grs_k_pseudo_node */
+
+       /* this nodes graph */
+       ext_grs_graph_t *graph;
+
+       char *name; /**< the name of this node */
+       /** This nodes action internal id. This id is also used
+        *  as index for match storage. */
+       int aiid;
+       /** this nodes ir op */
+       ir_op *op;
+       /** this nodes ir mode */
+       ir_mode *mode;
+       /** arrays of incoming and outgoing edges */
+       lc_list_t edges[2];
+       /** represents the memberships in the graphs node list  */
+       lc_list_t node_list;
+       /** a function representing a condition regarding the op of a firm
+        *  node which shall be matched with this (pattern or negative) node */
+       ext_grs_op_condition_func_t op_condition;
+       /** a function representing a condition regarding the mode of a firm
+        *  node which shall be matched with this (pattern or negative) node */
+       ext_grs_mode_condition_func_t mode_condition;
+       /** number of incoming replace edges not associated with a pattern
+        *  edge and having no specified position, these edges will be appended
+        *  to the exisiting in array in the rwrite step (only used in replacement
+        *  graphs) */
+       int n_append_edges;
+
+       /** index of the matcher op by which this node is first matched */
+       int first_mop_index;
+
+       /** some auxilary data needed to maintain a list of not yet processed nodes
+        * (see impl of Edmonds alogrithm in vs search planing) */
+       lc_list_t not_visited_list;
+
+       ext_grs_node_t *related_node;
+};
+
+typedef struct {
+       ext_grs_elem_kind_t kind;
+       union { ext_grs_node_t *n; struct _ext_grs_edge_t *e;} val;
+} ext_grs_elem_t;
+
+/** represents an edge in a grs rule */
+struct _ext_grs_edge_t
+{
+       ext_grs_elem_kind_t kind; /** mus be ext_grs_k_edge or ext_grs_k_pseudo_edge */
+
+       /* this edges graph */
+       ext_grs_graph_t *graph;
+
+       char *name; /**< the name of this edge */
+       /** This edges action internal id. This id is also used
+        *  as index for match storage. */
+       int aiid;
+       /** this edges position as an argument of its source node */
+       int pos;
+       /** this edges argument node, i.e. the node the result of which is
+        * processed by the function node */
+       ext_grs_node_t *arg;
+       /** this edges function node, i.e. the node using the argument for
+        *  further computations */
+       ext_grs_node_t *func;
+       /** if edge is a pseudo edge it represents follwing an edge against
+        *  its direction or the matching of a start node. Then this member
+        *  is a ptr to the edge or node represented */
+       ext_grs_elem_t genuine_elem;
+       /** for actual (non pseudo) edges: points to the pseudo edge
+        * representing the backward traversal of this edge */
+       ext_grs_edge_t *backward_edge;
+       /** for replacement edges, which have to be newly inserted, this function
+        *  computes the position the edge is inserted with at its func-node */
+       ext_grs_edge_pos_func_t position_func;
+       /* represents the membership in the graphs edge list
+        * (not for pseudo edges) */
+       lc_list_t edge_list;
+       /** represents the membership in this edge src- and tgt-nodes
+        * in and out lists (not for pseudo edges)  */
+       lc_list_t list[2];
+       /** index of the matcher op by which this edge is first matched */
+       int first_mop_index;
+
+
+       /** A field needed in the planing process:
+        *  represents this edges mambership in a
+        *  meldable priority queue of edges */
+       lc_list_t mpq_list;
+       /** A field needed in the planing process:
+        *  represents this edges cost in this actions cost graph during the planing process */
+       ext_grs_edge_cost_t cost;
+
+       ext_grs_edge_t *related_edge;
+};
+
+typedef enum {
+       ext_grs_k_pattern,
+       ext_grs_k_negative,
+       ext_grs_k_replacement
+} ext_grs_graph_kind_t;
+
+/** represents a pattern graph to be matched or inserted or
+ *  a negetive pattern graph */
+struct _ext_grs_graph_t {
+       ext_grs_graph_kind_t kind;
+       /** the action this pattern graph belongs to */
+       ext_grs_action_t *action;
+       /** number of this graphs nodes */
+       int n_nodes;
+        /** number of this graphs edges */
+       int n_edges;
+       /** number of this graphs conditions */
+       int n_conditions;
+       /**this graphs nodes */
+       lc_list_t nodes;
+       /**this graphs edges */
+       lc_list_t edges;
+       /** if this graph is a negative pattern this field represents the
+        *  membership in this graphs actions list of negative patterns */
+       lc_list_t negative_list;
+       /** A pseudo node needed for the computation of matching plans.
+        *  all edges incident to this node are pseudo edges representing
+        *  some kind of cost used in match planning */
+       ext_grs_node_t root_node;
+};
+
+
+/** An action the grs can perform. Possible kinds of actions are rules
+ * and tests. A rule describes the replacement of pattern graphs by a
+ * replacement graph, a test only describes the lookup for occurences of
+ * the pattern graphs, where it is not intended to perform a replacement */
+struct _ext_grs_action_t
+{
+       /** this actions kind (e.g. rule or test)*/
+       ext_grs_action_kind_t kind;
+       /** this actions id */
+       int id;
+       /** this actions name */
+       char *name;
+       /** flag: tells wether this action is mature or not. No changes
+        *  can be performed on the pattern, replacement or negative
+        *  patterns of a mature action */
+       int mature;
+
+
+       /* information concerning the matching */
+
+       /** the pattern graph */
+       ext_grs_graph_t *pattern;
+       /** list of all negative patterns if this action */
+       lc_list_t negatives;
+       /** overall number of real nodes of this action without pseudo and negative nodes */
+       int n_nodes;
+       /** overall number of real edges of this action without pseudo and negative edges */
+       int n_edges;
+       /** overall number of negative nodes of this action */
+       int n_neg_nodes;
+       /** overall number of negative edges of this action */
+       int n_neg_edges;
+       /** overall number of pseudo nodes of this action excluding the root node */
+       int n_pseudo_nodes;
+       /** overall number of pseudo edges of this action */
+       int n_pseudo_edges;
+
+       /** overall number of conditions registered with this action
+       *  (without op and mode conditions) */
+       int n_conditions;
+       /** the conditions registered with this action (without op and mode conditions) */
+       ext_grs_condition_func_t *conditions;
+       /** the aiids of the nodes involved in the condition with the given index */
+       lc_bitset_t **conds_involved_nodes;
+       /** the aiids of the edges involved in the condition with the given index */
+       lc_bitset_t **conds_involved_edges;
+       /** All conditions of this action stored as list of condition descriptors.
+       *  Only needed when the action is not yet mature. */
+       lc_list_t listed_conditions;
+
+       /** maximum (pattern or negative) node aiid present */
+       int max_node_aiid;
+       /** maximum (pattern or negative) edge aiid present */
+       int max_edge_aiid;
+       /** all (positive or negative) nodes of
+        *  this action (no replacement nodes) */
+       ext_grs_node_t **nodes;
+       /** the indices of the conditions refering the node of a given aiid */
+       lc_bitset_t **nodes_refering_conds;
+       /** all (positive or negative) edges of this action
+        *  (no replacement edges) */
+       ext_grs_edge_t **edges;
+       /** the indices of the conditions refering the edge of a given aiid */
+       lc_bitset_t **edges_refering_conds;
+
+       /** tells wether two nodes are allowed to be matched homomorphic.<br>
+        *  Usage: <code>act->hom[node1_id][mode2_id]</code> */
+       int **hom;
+
+       /** tells wether a positive and a negative node are related
+        *  Usage: <code>act->neg_node_relate[pat_node][neg_node]d</code>
+       int *neg_node_d;*/
+
+       /** tells wether a positive and a negative edge are related
+        * Usage: <code>act->neg_edge_relate[pat_edge][neg_edge]d</code>
+       int *neg_edge_related;*/
+
+       /** tells wether a node is allowed for multiple matching when
+        *  parallel rule application is intended
+        *  Usage: <code>act->critical[node_id]</code> */
+       int *node_critical;
+
+       /** tells wether an edge is allowed for multiple matching when
+        *  parallel rule application is intended
+        *  Usage: <code>act->critical[edge_id]</code> */
+       int *edge_critical;
+
+
+
+       /* information concerning the replacement */
+
+       /** the replacament graph (if action is a rule) */
+       ext_grs_graph_t *replacement;
+
+       /** if pattern node is to be kept
+        *      pattern_node_kept[pattern_node_index]
+        *  yields the replacement aiid of the corresponding
+        *  replace node and -1 otherwise */
+       int *pattern_node_kept;
+       /** if pattern edge is to be kept
+        *      pattern_node_kept[pattern_edge_index]
+        *  yields the replacement aiid of the corresponding
+        *  replace edge and -1 otherwise */
+       int *pattern_edge_kept;
+
+       /** number of nodes of the replacement graph */
+       int n_replacement_nodes;
+       /** The nodes of the replacement graph. The index is the nodes aiid, which is
+        *  unique ONLY for replacement nodes */
+       ext_grs_node_t **replacement_nodes;
+       /** number of edges of the replacement graph */
+       int n_replacement_edges;
+       /** the edges of the rplacement graph, index is the nodes aiid, which is
+        *  unique ONLY for replacement nodes */
+       ext_grs_edge_t **replacement_edges;
+       /** Tells wether a replacement node is to be newly inserted or kept:
+        *  -1 means to be inserted, >=0 means kept. If the node is kept,
+        *  the value equals the aiid of the corresponding pattern node.
+        *  USAGE: replacement_node_kept[replace_node_aiid] */
+       int *replacement_node_kept;
+       /** Tells wether a replacement edge is to be newly inserted or kept:
+        *  -1 means to be inserted, >=0 means kept. If the edge is kept,
+        *  the value equals the aiid of the corresponding pattern edge.
+        *  USAGE: replacement_edge_kept[replace_edge_aiid] */
+       int *replacement_edge_kept;
+       /** maximum replacement node aiid present */
+       int max_repl_node_aiid;
+       /** maximum replacement edge aiid present */
+       int max_repl_edge_aiid;
+       /** the list of functions to be evaluated directly after each rewrite step,
+        *  the evaluation is done in the order, the functions are stored
+        *  in this list */
+       lc_list_t listed_evals;
+
+       /** Stores pairs of nodes and edges associated to be kept nodes/edge.
+        *  Only needed when the action is not yet mature. */
+       lc_pset *kept_elems;
+};
+
+
+/** A condition descriptor. Describes which (pattern or negative) nodes
+ *  and/or edfes are involved in the condition represented by the given
+ *  condition function */
+typedef struct {
+       /** the action this condition belongs to */
+       struct _ext_grs_graph_t *graph;
+       /** the function representing the condition */
+       ext_grs_condition_func_t condition;
+       /** the number of involved nodes */
+       int n_nodes;
+       /** the involved nodes */
+       ext_grs_node_t **nodes;
+       /** the number of involved edges */
+       int n_edges;
+       /** the involved edges */
+       ext_grs_edge_t **edges;
+       /** represents the list of onditions of an action */
+       lc_list_t condition_list;
+} ext_grs_cond_descr_t;
+
+/** An eval descriptor. Respresents an eval function in
+ *  an actions list of evals */
+typedef struct {
+       /** the eval-in function */
+       ext_grs_eval_in_func_t eval_in;
+       /** the eval-out function */
+       ext_grs_eval_out_func_t eval_out;
+       /** represents the list of evals of an action */
+       lc_list_t eval_list;
+       /** some auxilary data used when finishing a match */
+       void *data;
+} ext_grs_eval_descr_t;
+
+/** Initialize the action part of the exr/grs module of the libfirm.
+ *  This is an internal function. */
+void _ext_grs_act_init(void);
+
+/** Finalize the action part of the exr/grs module of the libfirm.
+ *  This is an internal function. */
+void _ext_grs_act_finalize(void);
+
+
+
+#endif /* _EXT_GRS_ACTION_T_H_ */

diff --git a/ir/be/grgen/ana_vs.c b/ir/be/grgen/ana_vs.c
new file mode 100644 (file)
index 0000000..a88c68f
--- /dev/null
+++ b/ir/be/grgen/ana_vs.c
@@ -0,0 +1,514 @@
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/ana_vs.c
+ * Purpose:     implements the interfaces in analyze.h by a
+ *                             v-structure (vs) statistic (see [D"orr95],[Batz05b])
+ * Author:      Veit Batz
+ * Created:            22. June 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+/**
+ * @file       ext/grs/ana_vs.c
+ * @brief      implements the interfaces in analyze.h by a
+ *                     v-structure (vs) statistic (see [D"orr95],[Batz05b])
+ */
+
+#include "iredges_t.h"
+#include "irgwalk.h"
+
+#include "common_t.h"
+#include "analyze.h"
+#include "auxilary_t.h"
+#include "base_t.h"
+#include "ana_vs_t.h"
+
+
+
+/* counter for isomorphic arguments and result uses during analyses */
+static int *n_isomorphics;
+static int op_dim, mode_dim;
+#define N_ISOMORPHICS(opc, mc) n_isomorphics[(opc)*mode_dim + (mc)]
+
+
+/*  Counts isomorphic edeges incident at the current node
+ *  and stores some information in vs table.
+ *  To be called by an irg walker
+ *
+ * node   the current ir node
+ * env    the vs statistics object of the current ir graph
+ */
+static void ana_nodes_vs(ir_node *node, void *env)
+{
+
+       ext_grs_vs_stat_t *vs_stat = (ext_grs_vs_stat_t *) env;
+       ir_graph *irg = vs_stat->irg;
+       ext_grs_irg_private_t *pr_g = _ext_grs_get_irg_private(irg);
+       ext_grs_irn_private_t *pr_n = _ext_grs_get_irn_private(node);
+
+       const ir_edge_t *edge;
+
+       int j, k;
+       int n_ins = get_irn_arity(node);
+
+       int i = -1; /* for non Block nodes start at pos -1 */
+       ir_opcode opc = get_irn_opcode(node);
+       modecode mc = get_irn_modecode(node);
+
+
+
+       assert(vs_stat->irg == get_irn_irg(node) && "got wrong vs statistics");
+
+
+
+
+       /* add the current node to the appropriate node list */
+       lc_list_add(& pr_n->node_list, & _ext_grs_NODE_LIST(pr_g, opc, mc));
+       /* increment the node counter counting the node in that list */
+       (_ext_grs_N_INSTANCES(pr_g, opc, mc))++;
+       /* increment the counter counting the instances of an op for ANY mode */
+       if (mc != irm_ANY)
+               (_ext_grs_N_INSTANCES(pr_g, opc, irm_ANY))++;
+
+       /* count isomorphic arguments of the current node */
+       if (get_irn_op(node) == op_Block) i = 0;
+       for ( ; i < n_ins; i++) {
+
+               ir_node *arg = get_irn_n(node, i);
+               ir_opcode opc_arg = get_irn_opcode(arg);
+               modecode mc_arg = get_irn_modecode(arg);
+               ir_opcode super_opc_arg;
+
+
+               int n_super_ops = ARR_LEN(_ext_grs_all_super_ops_of_op[opc_arg]);
+
+               /* increment counters for the apropriate op and all super ops */
+               for (j = 0; j < n_super_ops; j++) {
+                       super_opc_arg = get_op_code(_ext_grs_all_super_ops_of_op[opc_arg][j]);
+                       N_ISOMORPHICS(super_opc_arg, mc_arg)++;
+                       N_ISOMORPHICS(super_opc_arg, irm_ANY)++;
+               }
+       }
+       /* store resulting number of v structures */
+       i = -1;
+       if (get_irn_op(node) == op_Block) i = 0;
+       n_ins = get_irn_arity(node);
+       for ( ; i < n_ins; i++) {
+
+               ir_node *arg = get_irn_n(node, i);
+               ir_opcode opc_arg = get_irn_opcode(arg);
+               modecode mc_arg = get_irn_modecode(arg);
+               ir_opcode super_opc_arg;
+
+
+#if(0)
+               int n_occ_add = 0;
+               int n_occ_any_add = 0;
+               int n_any_occ_add = 0;
+               int n_any_occ_any_add = 0;
+#endif
+
+               int n_super_ops = ARR_LEN(_ext_grs_all_super_ops_of_op[opc_arg]);
+
+               for (j = 0; j < n_super_ops; j++) {
+                       super_opc_arg = get_op_code(_ext_grs_all_super_ops_of_op[opc_arg][j]);
+                       if (N_ISOMORPHICS(super_opc_arg, mc_arg) > 0) {
+                               double x = _log2(N_ISOMORPHICS(super_opc_arg, mc_arg));
+
+#if(0)
+                               /* count the occurence of nodes with such an edge */
+                               n_occ_add++;
+                               if (mc != irm_ANY)
+                                       n_occ_any_add++;
+#endif
+
+                               /* accumulate multiplicity of such an edge */
+                               if (x > 0) {
+                                       /* and also add for all super ops of curent nodes op */
+                                       int n_super_ops_func = ARR_LEN(_ext_grs_all_super_ops_of_op[opc]);
+                                       for (k = 0; k < n_super_ops_func; k++) {
+                                               ir_opcode super_opc_func = get_op_code(_ext_grs_all_super_ops_of_op[opc][k]);
+
+                                               _add_n_v_structures(
+                                                       vs_stat, super_opc_func, mc, super_opc_arg, mc_arg, ext_grs_in, x);
+                                               if (mc != irm_ANY)
+                                                       _add_n_v_structures(vs_stat,
+                                                               super_opc_func, irm_ANY, super_opc_arg, mc_arg, ext_grs_in, x);
+
+                                       }
+                               }
+                               N_ISOMORPHICS(super_opc_arg, mc_arg) = 0;
+                       }
+                       if (N_ISOMORPHICS(super_opc_arg, irm_ANY) > 0) {
+                               double x = _log2(N_ISOMORPHICS(super_opc_arg, irm_ANY));
+
+#if(0)
+                               /* count the occurence of nodes with such an edge */
+                               n_any_occ_add++;
+                               if (mc != irm_ANY)
+                                       n_any_occ_any_add++;
+#endif
+
+                               /* accumulate multiplicity of such an edge */
+                               if (x > 0) {
+                                       /* and also add for all super ops of curent nodes op */
+                                       int n_super_ops_func = ARR_LEN(_ext_grs_all_super_ops_of_op[opc]);
+                                       for (k = 0; k < n_super_ops_func; k++) {
+                                               ir_opcode super_opc_func = get_op_code(_ext_grs_all_super_ops_of_op[opc][k]);
+
+                                               _add_n_v_structures(
+                                                       vs_stat, super_opc_func, mc, super_opc_arg, irm_ANY, ext_grs_in, x);
+                                               if (mc != irm_ANY)
+                                                       _add_n_v_structures(vs_stat,
+                                                               super_opc_func, irm_ANY, super_opc_arg, irm_ANY, ext_grs_in, x);
+                                       }
+                               }
+                               N_ISOMORPHICS(super_opc_arg, irm_ANY) = 0;
+                       }
+               }
+#if(0)
+               if (n_occ_add > 0)
+                       _add_n_occurence(vs_stat, opc, mc, opc_arg, mc_arg, ext_grs_in, n_occ_add);
+               if (n_occ_any_add > 0)
+                       _add_n_occurence(vs_stat, opc, irm_ANY, opc_arg, mc_arg, ext_grs_in, n_any_occ_add);
+               if (n_any_occ_add > 0)
+                       _add_n_occurence(vs_stat, opc, mc, opc_arg, irm_ANY, ext_grs_in, n_occ_any_add);
+               if (n_any_occ_any_add > 0)
+                       _add_n_occurence(vs_stat, opc, irm_ANY, opc_arg, irm_ANY, ext_grs_in, n_any_occ_any_add);
+#endif
+
+       }
+
+
+
+       /* count isomorphic uses of the current nodes result */
+       foreach_out_edge(node, edge) {
+
+               ir_node *res = get_edge_src_irn(edge);
+               ir_opcode opc_res = get_irn_opcode(res);
+               modecode mc_res = get_irn_modecode(res);
+
+               modecode super_opc_res;
+
+               int n_super_ops = ARR_LEN( _ext_grs_all_super_ops_of_op[opc_res]);
+
+               /* increment counters for the apropriate op and all super ops */
+               for (j = 0; j < n_super_ops; j++) {
+                       super_opc_res = get_op_code(_ext_grs_all_super_ops_of_op[opc_res][j]);
+                       N_ISOMORPHICS(super_opc_res, mc_res)++;
+                       N_ISOMORPHICS(super_opc_res, irm_ANY)++;
+               }
+       }
+       /* store resulting number of v structures */
+       foreach_out_edge(node, edge) {
+
+               ir_node *res = get_edge_src_irn(edge);
+               ir_opcode opc_res = get_irn_opcode(res);
+               modecode mc_res = get_irn_modecode(res);
+               modecode super_opc_res;
+
+#if(0)
+               int n_occ_add = 0;
+               int n_occ_any_add = 0;
+               int n_any_occ_add = 0;
+               int n_any_occ_any_add = 0;
+#endif
+
+               int n_super_ops = ARR_LEN( _ext_grs_all_super_ops_of_op[opc_res]);
+
+               for (j = 0; j < n_super_ops; j++) {
+                       super_opc_res = get_op_code(_ext_grs_all_super_ops_of_op[opc_res][j]);
+                       if (N_ISOMORPHICS(super_opc_res, mc_res) > 0) {
+
+                               double x = _log2(N_ISOMORPHICS(super_opc_res, mc_res));
+
+#if(0)
+                               /* count the occurence of nodes with such an edge */
+                               n_occ_add++;
+                               if (mc != irm_ANY)
+                                       n_any_occ_add++;
+#endif
+
+                               /* accumulate multiplicity of such an edge */
+                               if (x > 0) {
+                                       /* and also add for all super ops of curent nodes op */
+                                       int n_super_ops_func = ARR_LEN(_ext_grs_all_super_ops_of_op[opc]);
+                                       for (k = 0; k < n_super_ops_func; k++) {
+                                               ir_opcode super_opc_func = get_op_code(_ext_grs_all_super_ops_of_op[opc][k]);
+
+                                               _add_n_v_structures(
+                                                       vs_stat, super_opc_func, mc, super_opc_res, mc_res, ext_grs_out, x);
+                                               if (mc != irm_ANY)
+                                                       _add_n_v_structures(vs_stat,
+                                                               super_opc_func, irm_ANY, super_opc_res, mc_res, ext_grs_out, x);
+                                       }
+                               }
+                               N_ISOMORPHICS(super_opc_res, mc_res) = 0;
+                       }
+                       if (N_ISOMORPHICS(super_opc_res, irm_ANY) > 0) {
+
+                               double x = _log2(N_ISOMORPHICS(super_opc_res, irm_ANY));
+
+#if(0)
+                               /* count the occurence of nodes with such an edge */
+                               n_occ_any_add++;
+                               if (mc != irm_ANY)
+                                       n_any_occ_any_add++;
+#endif
+
+                               /* accumulate multiplicity of such an edge */
+                               if (x > 0) {
+                                       /* and also add for all super ops of curent nodes op */
+                                       int n_super_ops_func = ARR_LEN(_ext_grs_all_super_ops_of_op[opc]);
+                                       for (k = 0; k < n_super_ops_func; k++) {
+                                               ir_opcode super_opc_func = get_op_code(_ext_grs_all_super_ops_of_op[opc][k]);
+
+                                               _add_n_v_structures(
+                                                       vs_stat, super_opc_func, mc, super_opc_res, irm_ANY, ext_grs_out, x);
+                                               if (mc != irm_ANY)
+                                                       _add_n_v_structures(vs_stat,
+                                                               super_opc_func, irm_ANY, super_opc_res, irm_ANY, ext_grs_out, x);
+                                       }
+                               }
+                               N_ISOMORPHICS(super_opc_res, irm_ANY) = 0;
+                       }
+               }
+#if(0)
+               if (n_occ_add > 0)
+                       _add_n_occurence(vs_stat, opc, mc, opc_res, mc_res, ext_grs_out, n_occ_add);
+               if (n_any_occ_add > 0)
+                       _add_n_occurence(vs_stat, opc, irm_ANY, opc_res, mc_res, ext_grs_out, n_any_occ_add);
+               if (n_occ_any_add > 0)
+                       _add_n_occurence(vs_stat, opc, mc, opc_res, irm_ANY, ext_grs_out, n_occ_add);
+               if (n_any_occ_any_add > 0)
+                       _add_n_occurence(vs_stat, opc, irm_ANY, opc_res, irm_ANY, ext_grs_out, n_any_occ_add);
+#endif
+
+       }
+
+}
+
+/* initialize an vs analyzer */
+static void init(ext_grs_analyzer_t *alz) {
+
+       ext_grs_ana_vs_private_t *pr_a = malloc(sizeof(*pr_a));
+
+       /* init isomorphic edge counters with 0 */
+       op_dim = 170;
+       mode_dim = 25;
+       n_isomorphics = malloc(170*25*sizeof(int));
+       memset(n_isomorphics, 0, 170*25*sizeof(int));
+
+       /* init the pset mapping ir_graphs to that ir_graphs vs statistic */
+       pr_a->ana_results = lc_pset_new(_stat_cmp_func, 256);
+       /* init the global vs statistic */
+       pr_a->global_vs_stat.irg = NULL;
+       pr_a->global_vs_stat.stat = lc_pset_new(_vs_cmp_func, 256);
+       obstack_init(& pr_a->global_vs_stat.obst);
+
+       alz->data = pr_a;
+}
+
+/* perform string v structure analysis for a given graph */
+static void analyze(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       int j,k;
+       ext_grs_irg_private_t *pr_g = _ext_grs_get_irg_private(irg);
+       ext_grs_vs_stat_t *vs_stat;
+
+       assert(pr_g->matching_enabled && "matching not enabled for this graph");
+
+       edges_assure(irg);
+
+       /* check whether the array of instance counters is great enough */
+       if (_ext_grs_max_opcode >= op_dim) {
+               free(n_isomorphics);
+               op_dim = _ext_grs_max_opcode + 50;
+               n_isomorphics = malloc(op_dim*mode_dim*sizeof(int));
+               memset(n_isomorphics, 0, op_dim*mode_dim*sizeof(int));
+       }
+
+       if (_ext_grs_max_modecode >= mode_dim) {
+               free(n_isomorphics);
+               mode_dim = _ext_grs_max_modecode + 50;
+               n_isomorphics = malloc(op_dim*mode_dim*sizeof(int));
+               memset(n_isomorphics, 0, op_dim*mode_dim*sizeof(int));
+       }
+
+
+       /* init the op list heads */
+       for (j = 0; j < _ext_grs_irgpr_op_dim; j++)
+               for (k = 0; k < _ext_grs_irgpr_mode_dim; k++) {
+                       LC_INIT_LIST_HEAD(& _ext_grs_NODE_LIST(pr_g, j, k));
+                       _ext_grs_N_INSTANCES(pr_g, j, k) = 0;
+               }
+       /* init the number of (op,mode)-instances with zero */
+       memset(pr_g->n_instances, 0,
+               _ext_grs_irgpr_op_dim * _ext_grs_irgpr_mode_dim *
+                       sizeof(*(pr_g->n_instances)));
+
+       /* get the statistics object of the given irg and remove its complete contents */
+       vs_stat = _get_irg_vs_stat(alz, irg);
+       assert(vs_stat->irg == irg);
+
+       lc_pset_del(vs_stat->stat);
+       vs_stat->stat = lc_pset_new(_vs_cmp_func, 256);
+       obstack_free(& vs_stat->obst, NULL);
+       obstack_init(& vs_stat->obst);
+
+
+
+       irg_walk_graph(irg, ana_nodes_vs, NULL, vs_stat);
+}
+
+static void free_ana_result(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       ext_grs_vs_stat_t *vs_stat = _get_irg_vs_stat(alz, irg);
+
+       if (vs_stat->stat) {
+               lc_pset_del(vs_stat->stat);
+               vs_stat->stat = lc_pset_new(_vs_cmp_func, 256);
+       }
+
+       obstack_free(& vs_stat->obst, NULL);
+       obstack_init(& vs_stat->obst);
+}
+
+/* dump the current analysis result for a given ir graph */
+static void dump_ana_result(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       int i,j,k,l,r;
+       double x;
+       ext_grs_vs_stat_t *vs_stat = _get_irg_vs_stat(alz, irg);
+       ext_grs_irg_private_t *pr_g = _ext_grs_get_irg_private(irg);
+
+       printf("Dump vs-statistics for ir graph %ld...\n", get_irg_graph_nr(irg));
+
+       for (i=0; i <= _ext_grs_max_opcode; i++)
+               for (j=0; j <= _ext_grs_max_modecode; j++)
+                       for (k=0; k <= _ext_grs_max_opcode; k++)
+                               for (l=0; l <= _ext_grs_max_modecode; l++) {
+                                       x = _get_n_v_structures(vs_stat,i,j,k,l,ext_grs_in);
+                                       if (x > (double)0) {
+
+                                               int occ = _get_n_occurence(vs_stat, i, j, k, l, ext_grs_in);
+                                               int n_inst = 0;
+                                               double acc_div_occ = 0.0;
+                                               double acc_div_inst = 0.0;
+
+                                               /* compute the number of instances present for the
+                                                * func node (including all sub ops) */
+                                               for (r = 0; r < ARR_LEN(_ext_grs_all_sub_ops_of_op[i]); r++) {
+                                                       ir_opcode sub_opc = get_op_code(_ext_grs_all_sub_ops_of_op[i][r]);
+                                                       n_inst += _ext_grs_N_INSTANCES(pr_g, sub_opc, j);
+                                               }
+
+                                               if (occ > 0)
+                                                       acc_div_occ = x / occ;
+
+                                               if (n_inst > 0)
+                                                       acc_div_inst = x / (double)n_inst;
+
+                                               printf("# (%s, %s) -in-> (%s, %s): acc, occ, n_inst, acc/n_inst\n",
+                                                       get_op_name(_ext_grs_op_map[i]),
+                                                       get_mode_name(_ext_grs_mode_map[j]),
+                                                       get_op_name(_ext_grs_op_map[k]),
+                                                       get_mode_name(_ext_grs_mode_map[l])
+                                               );
+                                               printf("(%d,%d,%d,%d,in): %lf, %d, %d, %lf\n",
+                                                       i,j,k,l,
+                                                       x, occ, n_inst,
+                                                       acc_div_inst
+                                               );
+                                       }
+                                       x = _get_n_v_structures(vs_stat,i,j,k,l,ext_grs_out);
+                                       if (x > (double)0) {
+
+                                               int occ = _get_n_occurence(vs_stat, i, j, k, l, ext_grs_out);
+                                               int n_inst = 0;
+                                               double acc_div_occ = 0.0;
+                                               double acc_div_inst = 0.0;
+
+                                               /* compute the number of instnaces present for the
+                                                * func node (including all sub ops) */
+                                               for (r = 0; r < ARR_LEN(_ext_grs_all_sub_ops_of_op[i]); r++) {
+                                                       ir_opcode sub_opc = get_op_code(_ext_grs_all_sub_ops_of_op[i][r]);
+                                                       n_inst += _ext_grs_N_INSTANCES(pr_g, sub_opc, j);
+                                               }
+
+                                               if (occ > 0)
+                                                       acc_div_occ = x / occ;
+
+                                               if (n_inst > 0)
+                                                       acc_div_inst = x / (double)n_inst;
+
+                                               printf("# (%s, %s) <-out- (%s, %s): acc, occ, n_inst, acc/n_inst\n",
+                                                       get_op_name(_ext_grs_op_map[i]),
+                                                       get_mode_name(_ext_grs_mode_map[j]),
+                                                       get_op_name(_ext_grs_op_map[k]),
+                                                       get_mode_name(_ext_grs_mode_map[l])
+                                               );
+                                               printf("(%d,%d,%d,%d,out): %lf, %d, %d, %lf\n",
+                                                       i,j,k,l,
+                                                       x, occ, n_inst,
+                                                       acc_div_inst
+                                               );
+                                       }
+                               }
+
+       for (i=0; i <= _ext_grs_max_opcode; i++)
+               for (j=0; j <= _ext_grs_max_modecode; j++) {
+                       int n_inst = 0;
+                       const char *opname;
+                       const char *modename;
+
+                       for (r = 0; r < ARR_LEN(_ext_grs_all_sub_ops_of_op[i]); r++) {
+                               ir_opcode sub_opc = get_op_code(_ext_grs_all_sub_ops_of_op[i][r]);
+                               n_inst += _ext_grs_N_INSTANCES(pr_g, sub_opc, j);
+                       }
+
+                       if (_ext_grs_op_map[i] != NULL)
+                               opname = get_op_name(_ext_grs_op_map[i]);
+                       else opname = NULL;
+
+                       if (_ext_grs_mode_map[j] != NULL)
+                               modename = get_mode_name(_ext_grs_mode_map[j]);
+                       else modename = NULL;
+
+                       if (opname == NULL) opname = "dummy";
+                       if (modename == NULL) modename = "dummy";
+
+                       if (n_inst != 0 || _ext_grs_N_INSTANCES(pr_g, i,j) != 0)
+                               printf("Number of instances (%s, %s): direct = %d, with sub ops = %d\n",
+                                       opname, modename, _ext_grs_N_INSTANCES(pr_g, i,j), n_inst);
+               }
+
+
+       printf(" done\n");
+}
+
+
+
+
+
+
+
+
+
+static ext_grs_analyzer_t vs_analyzer;
+
+
+/** yields an analyzer performing a v-structure statisitc */
+ext_grs_analyzer_t *ext_grs_get_vs_analyzer(void)
+{
+       memset(&vs_analyzer, 0, sizeof(vs_analyzer));
+       vs_analyzer.tag = "vs_analyzer";
+       vs_analyzer.dump_ana_result = dump_ana_result;
+       vs_analyzer.analyze = analyze;
+       vs_analyzer.free_ana_result = free_ana_result;
+
+       init(&vs_analyzer);
+       return &vs_analyzer;
+}

diff --git a/ir/be/grgen/ana_vs.h b/ir/be/grgen/ana_vs.h
new file mode 100644 (file)
index 0000000..0a7c185
--- /dev/null
+++ b/ir/be/grgen/ana_vs.h
@@ -0,0 +1,34 @@
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/ana_vs.h
+ * Purpose:            provides an interface for getting a v-structure based analyzer
+ *
+ * Author:      Veit Batz
+ * Created:            22. June 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+/**
+ * @file       ext/grs/ana_vs.h
+ * @brief      provides an interface for getting a v-structure based analyzer
+ */
+
+#ifndef _EXT_GRS_ANA_VS_H_
+#define _EXT_GRS_ANA_VS_H_
+
+
+
+
+#include "analyze.h"
+
+
+
+/** yields an analyzer perorming a strong v structure statistic */
+ext_grs_analyzer_t *ext_grs_get_vs_analyzer(void);
+
+
+
+
+#endif /*_EXT_GRS_ANA_VS_H_*/

diff --git a/ir/be/grgen/ana_vs_t.h b/ir/be/grgen/ana_vs_t.h
new file mode 100644 (file)
index 0000000..1b329c3
--- /dev/null
+++ b/ir/be/grgen/ana_vs_t.h
@@ -0,0 +1,341 @@
+#ifndef _ANA_VS_T_H_
+#define _ANA_VS_T_H_
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/ana_vs_t.c
+ * Purpose:     internal interfaces of a v-structure (vs) statistic
+ *                             based graph analyzer (see [D"orr95],[Batz05b])
+ * Author:      Veit Batz
+ * Created:            30. July 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+/**
+ * @file       ext/grs/ana_vs_t.h
+ * @brief      internal interfaces of a v-structure (vs) statistic
+ *                     based graph analyzer (see [D"orr95],[Batz05b])
+ */
+
+#include <stdlib.h>
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+#include "common_t.h"
+#include "analyze_t.h"
+#include "ana_vs.h"
+
+
+
+
+
+
+/* an entry of a vs statistics which is represented by as pset */
+typedef struct _ext_grs_vs_counter_t {
+       ir_opcode o1, o2;
+       modecode m1, m2;
+       ext_grs_direction_t dir;
+       double counter; /* accumulated exponent of multoplicity */
+       int occurence; /* number of occurences of a node with such an edge */
+} ext_grs_vs_counter_t;
+
+
+typedef struct _ext_grs_vs_stat_t {
+       ir_graph *irg;
+       lc_pset *stat;
+       struct obstack obst;
+} ext_grs_vs_stat_t;
+
+typedef struct {
+       /* maps ir_graphs to vs statistics of the ir_graphs */
+       lc_pset *ana_results;
+       /* the global vs statistics */
+       ext_grs_vs_stat_t global_vs_stat;
+} ext_grs_ana_vs_private_t;
+
+
+
+
+#ifndef _ext_grs_VS_HASH
+#define _ext_grs_VS_HASH(c) \
+       HASH_PTR(\
+               (void *)(\
+                       ((unsigned)_ext_grs_op_map[(c)->o1]) ^ \
+                       ((unsigned)_ext_grs_op_map[(c)->o2]) ^ \
+                       ((unsigned)_ext_grs_mode_map[(c)->m1]) ^ \
+                       ((unsigned)_ext_grs_mode_map[(c)->m2]) ^ \
+                       ((unsigned)(c)->dir << 5) \
+               )\
+       )
+#endif
+
+/* compare function for a pset representing a vs statistics */
+static int _vs_cmp_func(const void *x1, const void *x2)
+{
+       ext_grs_vs_counter_t *c1, *c2;
+       c1 = (ext_grs_vs_counter_t *) x1;
+       c2 = (ext_grs_vs_counter_t *) x2;
+
+       /* if all entries are equal: return 0, else non-zero */
+       return (c1->o1 - c2->o1) | (c1->m1 - c2->m1) |
+              (c1->o2 - c2->o2) | (c1->m2 - c2->m2) |
+              (c1->dir - c2->dir) ;
+}
+
+static int _stat_cmp_func(const void *x1, const void *x2)
+{
+       ext_grs_vs_stat_t *s1, *s2;
+       s1 = (ext_grs_vs_stat_t *) x1;
+       s2 = (ext_grs_vs_stat_t *) x2;
+
+       /* if irg entries are equal: return 0, else non-zero */
+       return  s1->irg - s2->irg;
+}
+
+
+
+
+/* get the pset representing the given irgs vs statistics */
+static ext_grs_vs_stat_t
+*_get_irg_vs_stat(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       unsigned hash;
+       ext_grs_vs_stat_t dummy_stat, *stat;
+
+       lc_pset *res_set = ((ext_grs_ana_vs_private_t *)alz->data)->ana_results;
+
+       hash = HASH_PTR(irg);
+
+       dummy_stat.irg = irg;
+
+       /* lookup for the pset representing the irgs vs statitic */
+       stat = (ext_grs_vs_stat_t *)
+               lc_pset_find(res_set, &dummy_stat, HASH_PTR(irg));
+
+       /* if no such statistics present, create one */
+       if (stat == NULL) {
+
+               stat = malloc(sizeof(*stat));
+               assert (stat != NULL && "could not allocate missing irg statistics");
+               memset(stat, 0, sizeof(*stat));
+
+               /* set it up */
+               stat->irg = irg;
+               stat->stat = lc_pset_new(_vs_cmp_func, 256);
+               obstack_init(& stat->obst);
+
+               /* store stat in pset */
+               lc_pset_insert(res_set, stat, HASH_PTR(irg));
+       }
+       return stat;
+}
+
+
+
+
+
+/* add an onount to the given vs statistic */
+void static _add_n_v_structures(
+       ext_grs_vs_stat_t *vs_stat,
+       ir_opcode o1, modecode m1, ir_opcode o2, modecode m2,
+       ext_grs_direction_t dir, double x)
+{
+       unsigned hash;
+       ext_grs_vs_counter_t *count, *dummy_count;
+/*
+       printf("o1,m1,o2,m2,d: %s,%s,%s,%s,%d: %lf\n",
+                       get_op_name(_ext_grs_op_map[o1]),
+                       get_mode_name(_ext_grs_mode_map[m1]),
+                       get_op_name(_ext_grs_op_map[o2]),
+                       get_mode_name(_ext_grs_mode_map[m2]),
+                       dir,
+                       x
+               );
+ */
+       /* alloc a dummy stat entry on the stack */
+       dummy_count = alloca(sizeof(*dummy_count));
+
+       dummy_count->o1 = o1;
+       dummy_count->o2 = o2;
+       dummy_count->m1 = m1;
+       dummy_count->m2 = m2;
+       dummy_count->dir = dir;
+
+       hash = _ext_grs_VS_HASH(dummy_count);
+       count = lc_pset_find(vs_stat->stat, dummy_count, hash);
+
+       /* if entry already present, add counter */
+       if (count != NULL) {
+               count->counter += x;
+               return;
+       }
+
+       /* there's no stat entry present, so create one */
+       dummy_count = obstack_alloc(& vs_stat->obst, sizeof(*count));
+       dummy_count->o1 = o1;
+       dummy_count->o2 = o2;
+       dummy_count->m1 = m1;
+       dummy_count->m2 = m2;
+       dummy_count->dir = dir;
+       dummy_count->counter = x;
+       dummy_count->occurence = 0;
+       lc_pset_insert(vs_stat->stat, dummy_count, hash);
+}
+
+/* subtract an onount from the given vs statistic */
+void static _sub_n_v_structures(
+       ext_grs_vs_stat_t *vs_stat,
+       ir_opcode o1, modecode m1, ir_opcode o2, modecode m2,
+       ext_grs_direction_t dir, double x)
+{
+       unsigned hash;
+       ext_grs_vs_counter_t *count, *dummy_count;
+
+       /* alloc stat entry on the stat objects obstack */
+       dummy_count = (ext_grs_vs_counter_t *)
+               obstack_alloc(& vs_stat->obst, sizeof(*count));
+
+       dummy_count->o1 = o1;
+       dummy_count->o2 = o2;
+       dummy_count->m1 = m1;
+       dummy_count->m2 = m2;
+       dummy_count->dir = dir;
+
+       hash = _ext_grs_VS_HASH(dummy_count);
+       count = lc_pset_find(vs_stat->stat, dummy_count, hash);
+
+       /* if entry already present, add counter */
+       if (count != NULL) {
+               count->counter -= x;
+               obstack_free(& vs_stat->obst, dummy_count);
+               return;
+       }
+
+       /* if entry not present, store dummy_count as a new one */
+       dummy_count->counter = -x;
+       dummy_count->occurence = 0;
+       lc_pset_insert(vs_stat->stat, dummy_count, hash);
+}
+
+/* get the current multiplicity of the given vs */
+double static _get_n_v_structures(
+       ext_grs_vs_stat_t *vs_stat, ir_opcode o1, modecode m1, ir_opcode o2, modecode m2,
+       ext_grs_direction_t dir)
+{
+       unsigned hash;
+
+       ext_grs_vs_counter_t *count, dummy_count;
+       dummy_count.o1 = o1;
+       dummy_count.o2 = o2;
+       dummy_count.m1 = m1;
+       dummy_count.m2 = m2;
+       dummy_count.dir = dir;
+
+       hash = _ext_grs_VS_HASH(&dummy_count);
+
+       count = lc_pset_find(vs_stat->stat, &dummy_count, hash);
+
+       /* if entry already present return counter */
+       if (count != NULL) {
+               return count->counter;
+       }
+
+       /* otherwise return 0 */
+       return (double)0;
+}
+
+void static INLINE _inc_n_occurence(ext_grs_vs_stat_t *vs_stat,
+       ir_opcode o1, modecode m1, ir_opcode o2, modecode m2,   ext_grs_direction_t dir)
+{
+       unsigned hash;
+       ext_grs_vs_counter_t *count, *dummy_count;
+
+       /* alloc stat entry on the stat objects obstack */
+       dummy_count = (ext_grs_vs_counter_t *)
+               obstack_alloc(& vs_stat->obst, sizeof(*dummy_count));
+
+       dummy_count->o1 = o1;
+       dummy_count->o2 = o2;
+       dummy_count->m1 = m1;
+       dummy_count->m2 = m2;
+       dummy_count->dir = dir;
+
+       hash = _ext_grs_VS_HASH(dummy_count);
+       count = lc_pset_find(vs_stat->stat, dummy_count, hash);
+
+       /* if entry already present, add counter */
+       if (count != NULL) {
+               count->occurence++;
+               obstack_free(& vs_stat->obst, dummy_count);
+               return;
+       }
+
+       /* if entry not present, store dummy_count as a new one */
+       dummy_count->counter = (double)0;
+       dummy_count->occurence = 1;
+       lc_pset_insert(vs_stat->stat, dummy_count, hash);
+}
+
+void static INLINE _add_n_occurence(ext_grs_vs_stat_t *vs_stat,
+       ir_opcode o1, modecode m1, ir_opcode o2, modecode m2,   ext_grs_direction_t dir, int add)
+{
+       unsigned hash;
+       ext_grs_vs_counter_t *count, *dummy_count;
+
+       /* alloc stat entry on the stat objects obstack */
+       dummy_count = (ext_grs_vs_counter_t *)
+               obstack_alloc(& vs_stat->obst, sizeof(*count));
+
+       dummy_count->o1 = o1;
+       dummy_count->o2 = o2;
+       dummy_count->m1 = m1;
+       dummy_count->m2 = m2;
+       dummy_count->dir = dir;
+
+       hash = _ext_grs_VS_HASH(dummy_count);
+       count = lc_pset_find(vs_stat->stat, dummy_count, hash);
+
+       /* if entry already present, add counter */
+       if (count != NULL) {
+               count->occurence += add;
+               obstack_free(& vs_stat->obst, dummy_count);
+               return;
+       }
+
+       /* if entry not present, store dummy_count as a new one */
+       dummy_count->counter = (double)0;
+       dummy_count->occurence = 1;
+       lc_pset_insert(vs_stat->stat, dummy_count, hash);
+}
+
+
+int static _get_n_occurence(ext_grs_vs_stat_t *vs_stat,
+       ir_opcode o1, modecode m1, ir_opcode o2, modecode m2,   ext_grs_direction_t dir)
+{
+       unsigned hash;
+
+       ext_grs_vs_counter_t *count, dummy_count;
+       dummy_count.o1 = o1;
+       dummy_count.o2 = o2;
+       dummy_count.m1 = m1;
+       dummy_count.m2 = m2;
+       dummy_count.dir = dir;
+
+       hash = _ext_grs_VS_HASH(&dummy_count);
+
+       count = lc_pset_find(vs_stat->stat, &dummy_count, hash);
+
+       /* if entry already present return counter */
+       if (count != NULL) {
+               return count->occurence;
+       }
+
+       /* otherwise return 0 */
+       return 0;
+}
+
+
+#endif /*_ANA_VS_T_H_*/

diff --git a/ir/be/grgen/analyze.c b/ir/be/grgen/analyze.c
new file mode 100644 (file)
index 0000000..cc18ac6
--- /dev/null
+++ b/ir/be/grgen/analyze.c
@@ -0,0 +1,82 @@
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/analyze.c
+ * Purpose:     provides interfaces for incremental and from scratch
+ *                             analysis collection information for a search planer
+ * Author:      Veit Batz
+ * Created:            22. June 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+ /**
+  * @file ext/grs/analyze.c
+  * @brief     provides an interface for incremental and from scratch
+  *                    analyses collecting information for a search planer
+  * */
+
+#include "base_t.h"
+#include "analyze_t.h"
+
+
+/** perform a from scratch analysis of a given ir graph */
+void ext_grs_analyze(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       ext_grs_irg_private_t *pr_g = _ext_grs_get_irg_private(irg);
+       if (pr_g->matching_enabled) alz->analyze(alz, irg);
+}
+
+void ext_grs_free_ana_result(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       alz->free_ana_result(alz, irg);
+}
+
+
+/** enable incremantal analysis for the given ir graph */
+void ext_grs_enable_incr_ana(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       ext_grs_irg_private_t *pr_g = _ext_grs_get_irg_private(irg);
+       if (pr_g->matching_enabled) alz->enable_incr_ana(alz, irg);
+}
+
+/** disable incremantal analysis for the given ir graph */
+void ext_grs_disable_incr_ana(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       alz->disable_incr_ana(alz, irg);
+}
+
+/** dump the current analysis result for a given ir graph */
+void ext_grs_dump_ana_result(ext_grs_analyzer_t *alz, ir_graph *irg)
+{
+       alz->dump_ana_result(alz, irg);
+}
+
+
+
+
+
+/** from scratch analysis of all ir graphs building a global data set */
+void ext_grs_analyze_global(ext_grs_analyzer_t *alz)
+{
+       alz->analyze_global(alz);
+}
+
+/** enable global incremantal analysis building a global data set */
+void ext_grs_enable_global_incr_ana(ext_grs_analyzer_t *alz)
+{
+       alz->enable_global_incr_ana(alz);
+}
+
+/** disable global incremantal analysis building a global data set */
+void ext_grs_disable_global_incr_ana(ext_grs_analyzer_t *alz)
+{
+       alz->disable_global_incr_ana(alz);
+}
+
+/** dump the current global analysis result */
+void ext_grs_dump_global_ana_result(ext_grs_analyzer_t *alz)
+{
+       alz->dump_global_ana_result(alz);
+}

diff --git a/ir/be/grgen/analyze.h b/ir/be/grgen/analyze.h
new file mode 100644 (file)
index 0000000..4e88bf9
--- /dev/null
+++ b/ir/be/grgen/analyze.h
@@ -0,0 +1,49 @@
+#ifndef _EXT_GRS_ANALYZE_H_
+#define _EXT_GRS_ANALYZE_H_
+
+#include "common.h"
+
+typedef struct _ext_grs_analyzer_t ext_grs_analyzer_t;
+
+
+
+/** initialize an analyzer */
+void ext_grs_init_analyzer(ext_grs_analyzer_t *alz);
+
+/** perform a from scratch analysis of a given ir graph */
+void ext_grs_analyze(ext_grs_analyzer_t *alz, ir_graph *irg);
+
+/** free the result of the last analysis done on the given
+ *  ir graph by the given analyzer */
+void ext_grs_free_ana_result(ext_grs_analyzer_t *alz, ir_graph *irg);
+
+
+
+/** enable incremental analysis for the given ir graph */
+void ext_grs_enable_incr_ana(ext_grs_analyzer_t *alz, ir_graph *irg);
+
+/** disable incremental analysis for the given ir graph */
+void ext_grs_disable_incr_ana(ext_grs_analyzer_t *alz, ir_graph *irg);
+
+/** dump the current analysis result for a given ir graph */
+void ext_grs_dump_ana_result(ext_grs_analyzer_t *alz, ir_graph *irg);
+
+
+
+
+/** from scratch analysis of all ir graphs building a global data set */
+void ext_grs_analyze_global(ext_grs_analyzer_t *alz);
+
+/** enable global incremental analysis building a global data set */
+void ext_grs_enable_global_incr_ana(ext_grs_analyzer_t *alz);
+
+/** disable global incremental analysis building a global data set */
+void ext_grs_disable_global_incr_ana(ext_grs_analyzer_t *alz);
+
+/** dump the current global analysis result */
+void ext_grs_dump_global_ana_result(ext_grs_analyzer_t *alz);
+
+
+
+
+#endif /*_EXT_GRS_ANALYZE_H_*/

diff --git a/ir/be/grgen/analyze_t.h b/ir/be/grgen/analyze_t.h
new file mode 100644 (file)
index 0000000..8f4276d
--- /dev/null
+++ b/ir/be/grgen/analyze_t.h
@@ -0,0 +1,67 @@
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/analyze.h
+ * Purpose:     provides an interface for incremental and from scratch
+ *                             analysis for the collection of information needed by
+ *                             apropriate search planers
+ * Author:      Veit Batz
+ * Created:            22. June 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+/**
+ * @file ext/grs/analyze.h
+ * @brief      provides an interface for incremental and from scratch
+ *                     analysis for the collection of information needed by
+ *                     apropriate search planers
+ * */
+
+#ifndef _EXT_GRS_ANALYZE_T_H_
+#define _EXT_GRS_ANALYZE_T_H_
+
+
+#include "common_t.h"
+#include "analyze.h"
+
+
+
+
+/** interface of an ir graph analyzer */
+struct _ext_grs_analyzer_t
+{
+       /** a tag identifying an analyzer, to be checked by search planers */
+       const char *tag;
+
+       /** perform a from scratch analysis of a given ir graph */
+       void (*analyze) (struct _ext_grs_analyzer_t *, ir_graph *);
+       /** free the result of the last analysis done on the given
+        *  ir graph by this analyzer */
+       void (*free_ana_result) (ext_grs_analyzer_t *, ir_graph *);
+       /** enable incremantal analysis for the given ir graph */
+       void (*enable_incr_ana) (struct _ext_grs_analyzer_t *, ir_graph *);
+       /** disable incremantal analysis for the given ir graph */
+       void (*disable_incr_ana) (struct _ext_grs_analyzer_t *, ir_graph *);
+       /** dump the current analysis result */
+       void (*dump_ana_result) (struct _ext_grs_analyzer_t *, ir_graph *);
+
+       /** from scratch analysis of all ir graphs building a global data set */
+       void (*analyze_global) (struct _ext_grs_analyzer_t *);
+       /** enable global incremantal analysis building a global data set */
+       void (*enable_global_incr_ana) (struct _ext_grs_analyzer_t *);
+       /** disable global incremantal analysis building a global data set */
+       void (*disable_global_incr_ana) (struct _ext_grs_analyzer_t *);
+       /** dump the current global analysis result */
+       void (*dump_global_ana_result) (struct _ext_grs_analyzer_t *);
+
+       /** this analyzers private data storage area */
+       void *data;
+};
+
+
+
+
+
+#endif /*_EXT_GRS_ANALYZE_T_H_*/

diff --git a/ir/be/grgen/auxilary.c b/ir/be/grgen/auxilary.c
new file mode 100644 (file)
index 0000000..65de085
--- /dev/null
+++ b/ir/be/grgen/auxilary.c
@@ -0,0 +1,15 @@
+#include "auxilary_t.h"
+
+
+
+double _ext_grs_ln2;
+double _ext_grs_log_table[_ext_grs_MAX_LOG];
+
+void _ext_grs_log_table_init(void)
+{
+       int i;
+       _ext_grs_ln2 = log(2.0);
+       for (i=1; i < _ext_grs_MAX_LOG; i++) {
+               _ext_grs_log_table[i] = log((double)i) / _ext_grs_ln2;
+       }
+}

diff --git a/ir/be/grgen/auxilary_t.h b/ir/be/grgen/auxilary_t.h
new file mode 100644 (file)
index 0000000..95f6a54
--- /dev/null
+++ b/ir/be/grgen/auxilary_t.h
@@ -0,0 +1,32 @@
+#ifndef _EXT_GRS_AUXILARY_T_H_
+#define _EXT_GRS_AUXILARY_T_H_
+
+
+#include <math.h>
+#include "common_t.h"
+
+
+
+#ifndef ARR_SIZE
+#define ARR_SIZE(a)    (sizeof(a)/sizeof(a[0]))
+#endif
+
+
+#define _ext_grs_MAX_LOG 10000
+extern double _ext_grs_log_table[_ext_grs_MAX_LOG];
+extern double _ext_grs_ln2;
+
+
+void _ext_grs_log_table_init(void);
+
+static double INLINE _log2(int x) {
+
+       if (x >= ARR_SIZE(_ext_grs_log_table))
+               return log(x) / _ext_grs_ln2;
+
+       return _ext_grs_log_table[x];
+
+}
+
+
+#endif /* _EXT_GRS_AUXILARY_T_H_ */

diff --git a/ir/be/grgen/base.c b/ir/be/grgen/base.c
new file mode 100644 (file)
index 0000000..802aeca
--- /dev/null
+++ b/ir/be/grgen/base.c
@@ -0,0 +1,300 @@
+/*
+ * Project:     libFIRM/extension module/GRS-matcher
+ * File name:   ext/base.c
+ * Purpose:     Basic stuff for the firm graph rewriting module
+ * Author:      Veit Batz
+ * Created:            9. May 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+#ifdef HAVE_CONFIG_H
+       #include "config.h"
+#endif
+
+#include <stdlib.h>
+
+#include "irnode.h"
+
+
+#include "common_t.h"
+#include "auxilary_t.h"
+#include "base_t.h"
+#include "match_t.h"
+#include "grshooks_t.h"
+#include "action_t.h"
+
+/* maps opcodes to ops */
+ir_op **_ext_grs_op_map;
+/* maps modecodes to modes */
+ir_mode **_ext_grs_mode_map;
+
+/* a 2-dim flexible array telling wether an opcode belongs
+ * to a sub op of the op given by a second opcode. usage:
+ * _ext_grs_op_is_a[o1][o2] != 0   IFF   o1 inherits o2 */
+//int *_ext_grs_op_is_a = NULL;
+unsigned char *_ext_grs_op_is_a = NULL;
+/* the width of the  */
+int _ext_grs_op_is_a_width;
+
+/* a flexible array of flexible arrays each containing all inheriting
+ * firm ops of that firm op, the opcode of wich is the index entered
+ * in the array of arrays
+ * USAGE: _ext_grs_all_sub_ops_of_op[opcode]
+ * this yields an flexible array of ptrs to firm ops inheriting
+ * form the given opcodes op */
+ir_op ***_ext_grs_all_sub_ops_of_op = NULL;
+/* a flexible array of flexible arrays each containing all firm ops
+ * a given firm op inherits from, the given opcode is the index entered
+ * in the array of arrays
+ * USAGE: _ext_grs_all_super_ops_of_op[opcode]
+ * this yields an flexible array of ptrs to firm ops inheriting
+ * form the given opcodes op */
+ir_op ***_ext_grs_all_super_ops_of_op = NULL;
+
+/* dimension of dynamic allocated 2-dim arrays in private data
+ * area of firm graphs. These two arrays are the n_instances
+ * and the node_list. Note that these two arrays have the same
+ * dimension for all ir graphs. That means if the maximal
+ * opcode/modecode exceeds the respsective dimension the
+ * arrays of ALL ir graphs have to be reallcated (this is done
+ * by the hooks of new ops and modes) */
+int _ext_grs_irgpr_op_dim;
+int _ext_grs_irgpr_mode_dim;
+
+/* offset of custom data in ir nodes */
+unsigned _ext_grs_private_ofs_n;
+/* offset of custom data in ir graphs */
+unsigned _ext_grs_private_ofs_g;
+/* offset of custom data in ir edges */
+unsigned _ext_grs_private_ofs_e;
+
+/* maps ir op names (e.g. "Add") to ir ops (i.e. *ir_op) */
+lc_pset *_ext_grs_op_name_table;
+/* maps mode names (e.g. "M") to modes (i.e. *ir_mode) */
+lc_pset *_ext_grs_mode_name_table;
+/* remembers the maximum opcode present */
+int _ext_grs_max_opcode = 0;
+/* remembers the maximum modecode present */
+int _ext_grs_max_modecode = 0;
+
+
+/* op compare function for the hash table mapping op
+ * names to the appropriate firm objects */
+static int _op_cmp_func(const void *e1, const void *e2) {
+       const char *s1 = get_op_name((ir_op *) e1);
+       const char *s2 = get_op_name((ir_op *) e2);
+       int ret = strcmp(s1, s2);
+       assert ((ret != 0 || get_op_code((ir_op *) e1) == get_op_code((ir_op *) e1)) &&
+               "found different ir ops with an equal op name");
+       return ret;
+}
+
+/* mode compare function for the hash table mapping mode
+ * names to the appropriate firm objects */
+static int _mode_cmp_func(const void *e1, const void *e2) {
+       const char *s1 = get_mode_name((ir_mode *) e1);
+       const char *s2 = get_mode_name((ir_mode *) e2);
+       int ret = strcmp(s1, s2);
+       assert ((ret != 0 ||
+               get_mode_modecode((ir_mode *) e1) == get_mode_modecode((ir_mode *) e1)) &&
+               "found different ir modes with an equal mode name");
+       return ret;
+}
+
+
+#define INITAL_OP_SPACE 500
+
+/* activate the libfirm grs module */
+void ext_grs_activate(void)
+{
+       printf("activate libFIRM grs plugin... ");
+       /* private data of ir graphs, ir nodes and ir edges */
+       _ext_grs_private_ofs_n =
+               firm_register_additional_node_data(sizeof(ext_grs_irn_private_t));
+       _ext_grs_private_ofs_g =
+               register_additional_graph_data(sizeof(ext_grs_irg_private_t));
+       _ext_grs_private_ofs_e =
+               edges_register_private_data(sizeof(ext_grs_iredges_private_t));
+
+       /* init fast computation of log_2 */
+       _ext_grs_log_table_init();
+
+       /* init the hash tables mapping op and mode names to the respective firm objects */
+       _ext_grs_op_name_table = lc_pset_new(_op_cmp_func, 256);
+       _ext_grs_mode_name_table = lc_pset_new(_mode_cmp_func, 64);
+
+       /* init the flexible array representing the inheritance
+        * relation on firm ops */
+       _ext_grs_op_is_a = malloc(INITAL_OP_SPACE * INITAL_OP_SPACE*sizeof(*_ext_grs_op_is_a));
+       _ext_grs_op_is_a_width = INITAL_OP_SPACE;
+       memset(_ext_grs_op_is_a, 0, INITAL_OP_SPACE*INITAL_OP_SPACE*sizeof(*_ext_grs_op_is_a));
+
+       /* init the flexible array mapping op- and modecodes to ptrs */
+       _ext_grs_op_map = NEW_ARR_F(ir_op*, INITAL_OP_SPACE);
+       memset(_ext_grs_op_map, 0, INITAL_OP_SPACE * sizeof(*_ext_grs_op_map));
+       _ext_grs_mode_map = NEW_ARR_F(ir_mode*, 100);
+       memset(_ext_grs_mode_map, 0, 100 * sizeof(*_ext_grs_mode_map));
+
+       /* init the flexible array of flexible arrays keeping arrays of
+        * all sub ops of the op with the respective index as opcode */
+       _ext_grs_all_sub_ops_of_op = NEW_ARR_F(ir_op**, INITAL_OP_SPACE);
+       memset (_ext_grs_all_sub_ops_of_op, 0, INITAL_OP_SPACE * sizeof(ir_op**));
+       /* init the flexible array of flexible arrays keeping arrays of
+        * all sub ops of the op with the respective index as opcode */
+       _ext_grs_all_super_ops_of_op = NEW_ARR_F(ir_op**, INITAL_OP_SPACE);
+       memset (_ext_grs_all_super_ops_of_op, 0, INITAL_OP_SPACE* sizeof(ir_op**));
+
+       /* dimension of the dynamically 2-dim arrays n_instances and
+        * node_list in the private date area of ir graphs. */
+       _ext_grs_irgpr_op_dim = INITAL_OP_SPACE;
+       _ext_grs_irgpr_mode_dim = 25;
+
+       /* register firm some firm hooks */
+       _ext_grs_register_hooks();
+
+       /* init the matcher */
+       _ext_grs_match_init();
+       /* init the action part */
+       _ext_grs_act_init();
+
+       printf("done\n");
+}
+
+void ext_grs_finalize() {
+       _ext_grs_act_finalize();
+}
+
+/**
+ *  announce that firm op o1 inherits from firm op o2
+ */
+void ext_grs_appoint_heir(ir_op *o1, ir_op *o2) {
+
+       /* check params */
+       if (get_op_code(o2) > _ext_grs_max_opcode || get_op_code(o1) > _ext_grs_max_opcode) {
+               printf("module ext/grs: ERROR in function ext_grs_appoint_heir()\n");
+               printf("  Bad paramter: Unknown firm op.\n");
+               return;
+       }
+       if (o1 == o2) {
+               printf("module ext/grs: ERROR in function ext_grs_appoint_heir()\n");
+               printf("  The parameters given are equal.\n");
+               return;
+       }
+
+       /* the new entry into the inheritance table */
+       _ext_grs_OP_IS_A(get_op_code(o1), get_op_code(o2)) = 1;
+}
+
+void ext_grs_inheritance_mature(void) {
+
+       int i, j, k;
+
+       for (i = 0; i <= _ext_grs_max_opcode; i++) {
+
+               if(_ext_grs_all_sub_ops_of_op[i])
+                       DEL_ARR_F(_ext_grs_all_sub_ops_of_op[i]);
+               _ext_grs_all_sub_ops_of_op[i] = NEW_ARR_F(ir_op *, 1);
+               /* every op is subop of itself */
+               _ext_grs_all_sub_ops_of_op[i][0] = _ext_grs_op_map[i];
+
+               if(_ext_grs_all_super_ops_of_op[i])
+                       DEL_ARR_F(_ext_grs_all_super_ops_of_op[i]);
+               _ext_grs_all_super_ops_of_op[i] = NEW_ARR_F(ir_op *, 1);
+               /* every op is superop of itself */
+               _ext_grs_all_super_ops_of_op[i][0] = _ext_grs_op_map[i];
+       }
+
+       /* compute the transitive closure of the modified table
+        * using the Floyd-Warshall-Algorithm */
+       for (k = 0; k <= _ext_grs_max_opcode; k++)
+               for (i = 0; i <= _ext_grs_max_opcode; i++)
+                       for (j = 0; j <= _ext_grs_max_opcode; j++)
+                               _ext_grs_OP_IS_A(i,j) = _ext_grs_OP_IS_A(i,j) ||
+                                               (_ext_grs_OP_IS_A(i, k) && _ext_grs_OP_IS_A(k, j));
+
+       for (i = 0; i <= _ext_grs_max_opcode; i++)
+               for (j = 0; j <= _ext_grs_max_opcode; j++)
+                       if (_ext_grs_OP_IS_A(i,j)) {
+                               ARR_APP1(ir_op *, _ext_grs_all_sub_ops_of_op[j], _ext_grs_op_map[i]);
+                               ARR_APP1(ir_op *, _ext_grs_all_super_ops_of_op[i], _ext_grs_op_map[j]);
+                       }
+
+}
+
+ir_op *(ext_grs_lookup_op)(char *name) {
+       return _ext_grs_lookup_op(name);
+}
+
+ir_mode *(ext_grs_lookup_mode)(char *name) {
+       return _ext_grs_lookup_mode(name);
+}
+
+
+
+
+
+
+void ext_grs_enable_irg(ir_graph *irg)
+{
+       int i, j;
+       ext_grs_irg_private_t *pr_g;
+
+       if (!irg) {
+               printf("module ext/grs: ERROR in function ext_grs_enable_matching()\n");
+               printf("  Given ir graph was NULL.\n\n");
+               return;
+       }
+       pr_g = _ext_grs_get_irg_private(irg);
+
+       /* if matching is already enabled for this ir graph, do nothing */
+       if (pr_g->matching_enabled) return;
+
+       /* init the dyn array of the heads of all oplists */
+       pr_g->node_list =
+               malloc(_ext_grs_irgpr_op_dim * _ext_grs_irgpr_mode_dim *
+                       sizeof(*(pr_g->node_list)));
+
+       if (! pr_g->node_list) {
+               printf("module ext/grs: Internal ERROR in function ext_grs_enable_matching()\n");
+               printf("  Failed to allocate memory for internal data strucures.\n\n");
+               printf("  Aborting!\n\n");
+               abort();
+       }
+
+       for (i = 0; i < _ext_grs_irgpr_op_dim; i++)
+               for (j = 0; j < _ext_grs_irgpr_mode_dim; j++)
+                       LC_INIT_LIST_HEAD( &_ext_grs_NODE_LIST(pr_g, i, j) );
+
+       /* init the dyn array of number of instances of each pair (op,mode) */
+       pr_g->n_instances =
+               malloc(_ext_grs_irgpr_op_dim * _ext_grs_irgpr_mode_dim *
+                       sizeof(*(pr_g->n_instances)));
+       memset(pr_g->n_instances, 0,
+               _ext_grs_irgpr_op_dim * _ext_grs_irgpr_mode_dim *
+                       sizeof(*(pr_g->n_instances)));
+
+       /* matching now enabled */
+       pr_g->matching_enabled = 1;
+}
+
+void ext_grs_disable_irg(ir_graph *irg)
+{
+       ext_grs_irg_private_t *pr_g;
+
+       if (!irg) {
+               printf("module ext/grs: ERROR in function ext_grs_enable_matching()\n");
+               printf("  Given ir graph was NULL.\n\n");
+               return;
+       }
+       pr_g = _ext_grs_get_irg_private(irg);
+
+       /* if matching is already disabled for this ir graph, do nothing */
+       if (! pr_g->matching_enabled) return;
+
+       free(pr_g->node_list);
+       free(pr_g->n_instances);
+
+       /* matching now disabled */
+       pr_g->matching_enabled = 0;
+}

diff --git a/ir/be/grgen/base.h b/ir/be/grgen/base.h
new file mode 100644 (file)
index 0000000..7356794
--- /dev/null
+++ b/ir/be/grgen/base.h
@@ -0,0 +1,56 @@
+#ifndef _EXT_GRS_BASE_H_
+#define _EXT_GRS_BASE_H_
+
+
+
+#include "common.h"
+
+
+/**
+ * Activates the /ext/grs module.
+ * Must be called once \b before init_firm()
+ * if the ext/grs module of Firm should be used.
+ *
+ * @remark Call this function \b before init_firm()
+ */
+void ext_grs_activate(void);
+
+/** Finalize the /ext/grs module. */
+void ext_grs_finalize(void);
+
+/**
+ * get an ir_op by its name
+ */
+ir_op *ext_grs_lookup_op(char *op_name);
+
+/**
+ * get an ir_mode by its name
+ * */
+ir_mode *ext_grs_lookup_mode(char *name);
+
+/**
+ * announce that firm op o1 inherits from firm op o2
+ */
+void ext_grs_appoint_heir(ir_op *o1, ir_op *o2);
+
+/**
+ * Setup internal inheritance related data strucutres.
+ * @note       must be called after one or more invocations of
+ *                     ext_grs_appoint_heir()
+ */
+void ext_grs_inheritance_mature(void);
+
+/**
+ *  Enables subgraph matching for a given ir graph.\
+ */
+
+void ext_grs_enable_irg(ir_graph *irg);
+/**
+ *  Disables subgraph matching for a given irg, several internal
+ *  data structures will be freed (needed if there is not enough
+ *  memory to keep the data for all present ir graphs simultaneously.
+ */
+void ext_grs_disable_irg(ir_graph *irg);
+
+
+#endif /* _EXT_GRS_BASE_H_ */

diff --git a/ir/be/grgen/base_t.h b/ir/be/grgen/base_t.h
new file mode 100644 (file)
index 0000000..407c71f
--- /dev/null
+++ b/ir/be/grgen/base_t.h
@@ -0,0 +1,167 @@
+#ifndef _EXT_GRS_BASE_T_H_
+#define _EXT_GRS_BASE_T_H_
+
+
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+#include "common_t.h"
+#include "base.h"
+#include "action_t.h"
+
+
+
+
+
+#define OFFSET_OF(type, member) ((char*) &((((type)*)0)->(member)) - (char*)0)
+#define CONTAINER_OF(ptr, type, member) \
+       (((type) *) ((char *) (ptr) - OFFSET_OF((type), (member))))
+
+
+
+
+
+
+/* maps opcodes to ops */
+extern ir_op **_ext_grs_op_map;
+/* maps modecodes to modes */
+extern ir_mode **_ext_grs_mode_map;
+
+
+/**
+ * a 2-dim flexible array telling wether an opcode belongs
+ * to a sub op of the op given by a second opcode. usage:
+ * _ext_grs_op_is_a[o1][o2] != 0   IFF   o1 inherits o2 */
+//extern int *_ext_grs_op_is_a;
+extern unsigned char *_ext_grs_op_is_a;
+/** the width of the  */
+extern int _ext_grs_op_is_a_width;
+
+/** comfortable acces to the is_a matrix (o1 and o2 are opcodes) */
+#define _ext_grs_OP_IS_A(o1, o2) \
+       _ext_grs_op_is_a[((int)o1)*(_ext_grs_op_is_a_width) + ((int)o2)]
+
+/**
+ * a flexible array of flexible arrays each containing all inheriting
+ * firm ops of that firm op, the opcode of wich is the index entered
+ * in the array of arrays
+ * USAGE: _ext_grs_all_sub_ops_of_op[opcode]
+ * this yields an flexible array of ptrs to firm ops inheriting
+ * form the given opcodes op */
+extern ir_op ***_ext_grs_all_sub_ops_of_op;
+/* a flexible array of flexible arrays each containing all firm ops
+ * a given firm op inherits from, the given opcode is the index entered
+ * in the array of arrays
+ * USAGE: _ext_grs_all_super_ops_of_op[opcode]
+ * this yields an flexible array of ptrs to firm ops inheriting
+ * form the given opcodes op */
+extern ir_op ***_ext_grs_all_super_ops_of_op;
+
+/** maps ir op names (e.g. "Add") to ir ops (i.e. *ir_op) */
+extern lc_pset *_ext_grs_op_name_table;
+/** maps mode names (e.g. "M") to modes (i.e. *ir_mode) */
+extern lc_pset *_ext_grs_mode_name_table;
+/** remembers the maximum opcode present */
+extern int _ext_grs_max_opcode;
+/** remembers the maximum modecode present */
+extern int _ext_grs_max_modecode;
+
+
+/** offset of private data area in ir graphs */
+extern unsigned _ext_grs_private_ofs_g;
+/** the private data area in ir graphs */
+typedef struct _ext_grs_irg_private_t {
+       /** a flag, tells wether matching has been disabled
+        *  for this it graph by calling ext_grs_disable_matching() */
+       int matching_enabled;
+       /** lists of firm nodes according to their opcode and modecode */
+       lc_list_t *node_list;
+       /** number of instances according to the opcode and modecode */
+       int *n_instances;
+} ext_grs_irg_private_t;
+
+/* dimension of dynamic allocated 2-dim arrays in private data
+ * area of firm graphs. These two arrays are the n_instances
+ * and the node_list. Note that these two arrays have the same
+ * dimension for all ir graphs. That means if the maximal
+ * opcode/modecode exceeds the respsective dimension the
+ * arrays of ALL ir graphs have to be reallcated (this is done
+ * by the hooks of new ops and modes) */
+extern int _ext_grs_irgpr_op_dim;
+extern int _ext_grs_irgpr_mode_dim;
+
+/* easy acces two these dynamic 2-dim arrays */
+#define _ext_grs_N_INSTANCES(pr_g, opc, mc) \
+       ((pr_g)->n_instances[_ext_grs_irgpr_mode_dim * (opc) + (mc)])
+#define _ext_grs_NODE_LIST(pr_g, opc, mc) \
+       ((pr_g)->node_list[_ext_grs_irgpr_mode_dim * (opc) + (mc)])
+
+/** offset of private data in ir nodes */
+extern unsigned _ext_grs_private_ofs_n;
+/** the private data area in ir nodes */
+typedef struct _ext_grs_irn_private_t {
+       /** list of firm nodes according to this nodes opcode and modecode */
+       lc_list_t node_list;
+       /** some auxilary data, needed to determine wether a ir node has
+        * already been matched. If so, it points to a pattern node it is
+        * matched from, otherwise it is NULL */
+       ext_grs_node_t *preimage;
+       /** flag, tells wether this nodes has been deleted on a rewrite step */
+       int deleted;
+} ext_grs_irn_private_t;
+
+
+/** offset of private data in ir edges */
+extern unsigned _ext_grs_private_ofs_e;
+/** the private data area in ir edges */
+typedef struct _ext_grs_iredges_private_t {
+       ext_grs_edge_t *preimage;
+       unsigned long visited;
+} ext_grs_iredges_private_t;
+
+
+static INLINE ext_grs_irn_private_t *_ext_grs_get_irn_private(ir_node *irn) {
+       return get_irn_data(irn, ext_grs_irn_private_t, _ext_grs_private_ofs_n);
+}
+
+static INLINE ext_grs_irg_private_t *_ext_grs_get_irg_private(ir_graph *irg) {
+       return get_irg_data(irg, ext_grs_irg_private_t, _ext_grs_private_ofs_g);
+}
+
+static INLINE ir_op *_ext_grs_lookup_op(char *op_name) {
+
+       ir_op *op = alloca(sizeof(*op));
+
+       memset(op, 0, sizeof(*op));
+       op->name = new_id_from_str(op_name);
+
+       op = lc_pset_find(
+               _ext_grs_op_name_table, op, HASH_STR(op_name, strlen(op_name)));
+       return op;
+}
+
+static INLINE ir_mode *_ext_grs_lookup_mode(char *name) {
+
+       ir_mode *mode = alloca(sizeof(*mode));
+
+       memset(mode, 0, sizeof(*mode));
+       mode->name = new_id_from_str(name);
+
+       mode = lc_pset_find(
+               _ext_grs_mode_name_table, mode, HASH_STR(name, strlen(name)));
+       return mode;
+}
+
+/** get an op by its name */
+#define ext_grs_lookup_op(name)                                        _ext_grs_lookup_op((name))
+/** get a mode by its name */
+#define ext_grs_lookup_mode(name)                              _ext_grs_lookup_mode((name))
+
+
+
+
+
+
+#endif /* _EXT_GRS_BASE_T_H_ */

diff --git a/ir/be/grgen/common.h b/ir/be/grgen/common.h
new file mode 100644 (file)
index 0000000..9cfd8e1
--- /dev/null
+++ b/ir/be/grgen/common.h
@@ -0,0 +1,15 @@
+#ifndef _EXT_GRS_COMMON_H_
+#define _EXT_GRS_COMMON_H_
+
+
+
+#include <firm_config.h>
+#include <irop.h>
+#include <irmode.h>
+#include <irnode.h>
+
+#define DUMP_WHILE_MATCHING   0
+
+//#define EXT_GRS_DEBUG
+
+#endif /* _EXT_GRS_COMMON_H_ */

diff --git a/ir/be/grgen/common_t.h b/ir/be/grgen/common_t.h
new file mode 100644 (file)
index 0000000..62ea5bd
--- /dev/null
+++ b/ir/be/grgen/common_t.h
@@ -0,0 +1,33 @@
+#ifndef _EXT_GRS_COMMON_T_H_
+#define _EXT_GRS_COMMON_T_H_
+
+
+
+#include <libcore/lc_pset.h>
+#include <libcore/lc_list.h>
+
+#ifdef HAVE_CONFIG_H
+       #include "config.h"
+#endif
+
+#include "irgraph_t.h"
+#include "irop_t.h"
+#include "irmode_t.h"
+#include "irnode_t.h"
+#include "iredges_t.h"
+
+
+
+
+typedef enum {
+       ext_grs_in = 0,
+       ext_grs_out = 1
+} ext_grs_direction_t;
+
+
+
+
+
+
+
+#endif /* _EXT_GRS_COMMON_T_H_ */

diff --git a/ir/be/grgen/grs.h b/ir/be/grgen/grs.h
new file mode 100644 (file)
index 0000000..6f9ba6e
--- /dev/null
+++ b/ir/be/grgen/grs.h
@@ -0,0 +1,13 @@
+#ifndef _EXT_GRS_GRS_H_
+#define _GRS_H_
+
+#include "common.h"
+#include "base.h"
+#include "action.h"
+#include "analyze.h"
+#include "ana_vs.h"
+#include "match.h"
+#include "matchplan.h"
+#include "plan_vs_dmst.h"
+
+#endif /*_EXT_GRS_GRS_H_*/

diff --git a/ir/be/grgen/grshooks.c b/ir/be/grgen/grshooks.c
new file mode 100644 (file)
index 0000000..c3a9401
--- /dev/null
+++ b/ir/be/grgen/grshooks.c
@@ -0,0 +1,252 @@
+/*
+ * Project:     libFIRM/extension module/GRS-matcher
+ * File name:   ext/base.c
+ * Purpose:     hook register stuff
+ * Author:      Veit Batz
+ * Modified by: Andreas Schoesser
+ * Created:            9. May 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+#include <stdlib.h>
+
+#include "irhooks.h"
+#include "common_t.h"
+#include "base_t.h"
+#include "irtools.h"
+
+#include "grshooks_t.h"
+
+
+
+// #define MAX(a, b) (((a)>=(b)) ? (a) : (b))
+
+
+
+/* array of all hooks used by the matcher */
+hook_entry_t _ext_grs_hooks[hook_last];
+
+
+/* auxilary function reallocating the 2-dim dynamic arrays
+ * n_instances and node_list in the private data area of
+ * ir graphs */
+static void realloc_all_irgpr(void)
+{
+       ir_graph *irg;
+       int n_irgs = get_irp_n_allirgs();
+       int i,j,k,opc,mc;
+       ext_grs_irg_private_t *pr_g;
+
+       int old_mode_dim = _ext_grs_irgpr_mode_dim;
+       int old_op_dim = _ext_grs_irgpr_op_dim;
+
+       _ext_grs_irgpr_op_dim = MAX(_ext_grs_max_opcode + 50, old_op_dim);
+       _ext_grs_irgpr_mode_dim = MAX(_ext_grs_max_modecode + 50, old_mode_dim);
+
+
+       for (i=0 ; i<n_irgs ; i++) {
+               lc_list_t *old_node_list;
+               int *old_n_ins;
+
+               /* get the current irg */
+               irg = get_irp_allirg(i);
+               pr_g = _ext_grs_get_irg_private(irg);
+
+               /* if matching not enabled, there are no data structres
+                * present which have to be reallocated */
+               if (! pr_g->matching_enabled) continue;
+
+               /* alloc a new node list array */
+               old_node_list = pr_g->node_list;
+               pr_g->node_list = malloc(
+                       _ext_grs_irgpr_op_dim * _ext_grs_irgpr_mode_dim * sizeof(*(pr_g->node_list)));
+               /* init the list heads */
+               for (j = 0; j < _ext_grs_irgpr_op_dim; j++)
+                       for (k = 0; k < _ext_grs_irgpr_mode_dim; k++)
+                               LC_INIT_LIST_HEAD(& _ext_grs_NODE_LIST(pr_g, j, k));
+
+               /* alloc a new array of instance counters */
+               old_n_ins = pr_g->n_instances;
+               pr_g->n_instances = malloc(
+                       _ext_grs_irgpr_op_dim * _ext_grs_irgpr_mode_dim * sizeof(*(pr_g->n_instances)));
+               memset(pr_g->n_instances, 0,
+                       _ext_grs_irgpr_op_dim * _ext_grs_irgpr_mode_dim * sizeof(*(pr_g->n_instances)));
+
+               /* copy everything from the old to the new one */
+               for (opc = 0; opc < old_op_dim; opc++)
+                       for (mc = 0; mc < old_mode_dim; mc++) {
+                               _ext_grs_NODE_LIST(pr_g, opc, mc) =
+                                       old_node_list[old_mode_dim * opc + mc];
+                               _ext_grs_N_INSTANCES(pr_g, opc, mc) =
+                                       old_n_ins[old_mode_dim * opc + mc];
+                       }
+               free(old_node_list);
+               free(old_n_ins);
+       }
+}
+
+
+
+
+static void _hook_new_mode(void *context, const ir_mode *tmpl, ir_mode *mode)
+{
+       int old_len, new_len;
+       modecode new_modecode = get_mode_modecode(mode);
+
+       /* add pair (name, *ir_mode) to hash table */
+       const char *name = get_mode_name(mode);
+       int len = strlen(name);
+       lc_pset_insert(_ext_grs_mode_name_table, mode, HASH_STR(name, len));
+
+       if(new_modecode < 0)
+               return;
+
+
+       /* if new modecode is greater than any other modecode present */
+       if (new_modecode > _ext_grs_max_modecode) {
+               /* ensure that the flexible array is great enough */
+               old_len = ARR_LEN(_ext_grs_mode_map);
+               ARR_EXTO(*_ext_grs_mode_map, _ext_grs_mode_map, new_modecode + 1);
+               new_len = ARR_LEN(_ext_grs_mode_map);
+               if (new_len > old_len)
+                       memset(& _ext_grs_mode_map[old_len], 0,
+                               sizeof(*_ext_grs_mode_map) * (new_len - old_len) );
+               /* remember the maximum opcode present */
+               _ext_grs_max_modecode = new_modecode;
+       }
+
+       /* map modecodes to modes */
+       if (_ext_grs_mode_map[new_modecode])
+               printf("WARNING in module ext/grs: multiple modecode encountered: %s, %d\n",
+                       name, new_modecode);
+/*     else printf("new modecode: %s, %d\n", name, new_modecode);*/
+
+       _ext_grs_mode_map[new_modecode] = mode;
+
+       /* if the new maximal opcode exceeds the dimension of the dynamic
+        * n_instance and the node_list array in they have to be allocated
+        * for ALL ir graphs present */
+       if (_ext_grs_max_modecode >= _ext_grs_irgpr_mode_dim)
+               realloc_all_irgpr();
+}
+
+
+static void _hook_new_ir_op(void *context, ir_op *op)
+{
+       ir_opcode new_opcode = get_op_code(op);
+
+       /* add pair (name, *ir_op) to hash table */
+       const char *name = get_op_name(op);
+       int len = strlen(name);
+
+
+       ir_op** op_array;
+
+       lc_pset_insert(_ext_grs_op_name_table, op, HASH_STR(name, len));
+
+       /* if array is to small... */
+       if (new_opcode >= _ext_grs_op_is_a_width) {
+               unsigned char *old_array = _ext_grs_op_is_a;
+               int old_width = _ext_grs_op_is_a_width;
+               int new_len;
+               int i,j;
+
+               /* resize array  >>>> BUGGY!!!! <<<<< */
+               _ext_grs_op_is_a_width += 20;
+               new_len = _ext_grs_op_is_a_width * _ext_grs_op_is_a_width; //(new_opcode+20) * (new_opcode+20);
+               _ext_grs_op_is_a = malloc(new_len*sizeof(unsigned char));
+               memset(_ext_grs_op_is_a, 0, new_len*sizeof(unsigned char));
+
+               /* because of being 2-dim we have to copy the content ourselves */
+               for (i = 0; i < old_width/*_ext_grs_op_is_a_width*/; i++)
+                       for (j = 0; j < old_width/*_ext_grs_op_is_a_width*/; j++)
+                               _ext_grs_OP_IS_A(i,j) =
+                                       old_array[i * (old_width) + j];
+
+               /* delete the old array */
+               free(old_array);
+       }
+
+       /* assure that the arrays representing the op map and
+        * the sets of sub ops of a given op are great enough */
+       /* if new opcode is greater than any other opcode present */
+       if (new_opcode > _ext_grs_max_opcode) {
+               /* ensure that the op map array is graet enough */
+               int old_len, new_len;
+
+               old_len = ARR_LEN(_ext_grs_op_map);
+               ARR_EXTO(ir_op*, _ext_grs_op_map, new_opcode + 1);
+               new_len = ARR_LEN(_ext_grs_op_map);
+               if (new_len > old_len)
+                       memset( & _ext_grs_op_map[old_len], 0,
+                               sizeof(*_ext_grs_op_map) * (new_len - old_len) );
+
+               /* ensure that the sub op array is great enough */
+               old_len = ARR_LEN(_ext_grs_all_sub_ops_of_op);
+               ARR_EXTO(ir_op**, _ext_grs_all_sub_ops_of_op, new_opcode + 1);
+               new_len = ARR_LEN(_ext_grs_all_sub_ops_of_op);
+               if (new_len > old_len)
+                       memset( & _ext_grs_all_sub_ops_of_op[old_len], 0,
+                               sizeof(*_ext_grs_all_sub_ops_of_op) * (new_len - old_len) );
+
+               /* ensure that the super op array is great enough */
+               old_len = ARR_LEN(_ext_grs_all_super_ops_of_op);
+               ARR_EXTO(ir_op**, _ext_grs_all_super_ops_of_op, new_opcode + 1);
+               new_len = ARR_LEN(_ext_grs_all_super_ops_of_op);
+               if (new_len > old_len)
+                       memset( & _ext_grs_all_super_ops_of_op[old_len], 0,
+                               sizeof(*_ext_grs_all_super_ops_of_op) * (new_len - old_len) );
+
+               /* remember the maximum opcode present */
+               _ext_grs_max_opcode = new_opcode;
+       }
+
+       /* map opcodes to ops */
+       if (_ext_grs_op_map[new_opcode] != NULL)
+               printf("WARNING in module ext/grs: multiple opcode of op %s encountered: %d\n",
+                       name, new_opcode);
+/*     else printf("new opcode of op %s encountered: %d\n", name, new_opcode);*/
+
+       _ext_grs_op_map[new_opcode] = op;
+
+       /* if the new maximal opcode exceeds the dimension of the dynamic
+        * n_instance and the node_list array in they have to be allocated
+        * for ALL ir graphs present */
+       if (_ext_grs_max_opcode >= _ext_grs_irgpr_op_dim)
+               realloc_all_irgpr();
+
+       /* every op is a subop of itself */
+       op_array = _ext_grs_all_sub_ops_of_op[new_opcode];
+       if (op_array == NULL) /* this is because of multiple opcodes */ {
+               op_array = NEW_ARR_F(ir_op*, 1);
+               op_array[0] = op;
+               /* if ptr has changed... */
+               _ext_grs_all_sub_ops_of_op[new_opcode] = op_array;
+       }
+
+       /* every op is a superop of itself */
+       op_array = _ext_grs_all_super_ops_of_op[new_opcode];
+       if (op_array == NULL) /* this is because of multiple opcodes */ {
+               op_array = NEW_ARR_F(ir_op*, 1);
+               op_array[0] = op;
+               /* if ptr has changed... */
+               _ext_grs_all_super_ops_of_op[new_opcode] = op_array;
+       }
+}
+
+
+void _ext_grs_register_hooks(void) {
+       /* simplify hook registrtation */
+       #define HOOK(h, fkt) \
+               _ext_grs_hooks[h].hook._##h = fkt; register_hook(h, &_ext_grs_hooks[h])
+
+       /* register op creation hook */
+       HOOK(hook_new_ir_op, _hook_new_ir_op);
+       /* register mode creation hooks */
+       HOOK(hook_new_mode, _hook_new_mode);
+       /* HOOK(hook_new_vector_mode, _hook_new_vector_mode);*/
+
+       #undef HOOK
+}

diff --git a/ir/be/grgen/grshooks_t.h b/ir/be/grgen/grshooks_t.h
new file mode 100644 (file)
index 0000000..c121d7a
--- /dev/null
+++ b/ir/be/grgen/grshooks_t.h
@@ -0,0 +1,8 @@
+#ifndef _EXT_GRS_GRSHOOKS_T_H_
+#define _EXT_GRS_GRSHOOKS_T_H_
+
+
+void _ext_grs_register_hooks(void);
+
+
+#endif /*_EXT_GRS_GRSHOOKS_T_H_*/

diff --git a/ir/be/grgen/match.c b/ir/be/grgen/match.c
new file mode 100644 (file)
index 0000000..c47c3fa
--- /dev/null
+++ b/ir/be/grgen/match.c
@@ -0,0 +1,2140 @@
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/match.c
+ * Purpose:     provides functions for subgraph matching
+ * Author:      Veit Batz
+ * Modified by: Andreas Schoesser
+ * Created:            7. Junly 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+#include <stdlib.h>
+#include <libcore/lc_pset.h>
+#include "firm.h"
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+#include "firm_types.h"
+#include "array.h"
+#include "ircons_t.h"
+#include "irdump_t.h"
+#include "irnode_t.h"
+#include "iredges.h"
+#include "base_t.h"
+#include "match_t.h"
+
+
+/* just a prototype */
+static void match_rec(void);
+
+
+#undef MAX
+#define MAX(a,b) ((a) >= (b) ? (a) : (b))
+
+
+
+/* the match dumper stores ir nodes and edges of a given match in hash tables
+ * such that it can determine whether a ir node or edge has to be highlighted or not */
+typedef struct _ext_grs_matched_graph_elem_t {
+       /* tells whether a node or an edge is matched */
+       ext_grs_elem_kind_t kind;
+       /* the matched graph elem (a node or an edge) */
+       union {ir_node *irn; const ir_edge_t *ire;} elem;
+       /* tells whether this elem is matched for a given match id */
+       int *matched;
+       /* an array of index lists, tells the indeces in the
+        * espective match (if matched at all) */
+       lc_list_t *aiids;
+}
+ext_grs_matched_graph_elem_t;
+
+typedef struct {
+       int aiid;
+       lc_list_t list;
+} ext_grs_matched_aiids_t;
+
+
+/* elem of the list of found matches */
+struct ext_grs_match_list_head {
+       lc_list_t list;
+       ir_node **nodes;
+       ir_edge_t **edges;
+};
+
+
+
+/* Some global variables needed by the recursive matching algorithm.
+ * This helps saving parameters */
+
+/* the current matcher prog */
+static ext_grs_match_op_t *prog = NULL;
+/* the length of the current matcher prog */
+static int length = 0;
+/* the current position in the match program */
+static int mpos = 0;
+/* the maximum number of matches that shall be found (-1 means ALL) */
+static int max_n_matches;
+/* tells whether the matching shall guaranty the parallel
+ * applicability of the given action for ALL found matches:
+ * zero means no, nonzero mens yes */
+static int match_compliant;
+/* the current visit phase of the current irg. This info is necessary
+ * to mark all nodes and edges which have already been matched by a
+ * pattern node which does not guaranty parallel applicability in
+ * multiple matches */
+static unsigned long irg_visit_phase;
+/* tells to which op index the backtracking has to brunch back, when a match
+ * is found */
+static int return_to_mop_index;
+
+/* flag, tells whether a invocation of match_rec is for the pattern or a NAC */
+static int match_negative_pattern = 0;
+static int found_negative;
+
+/** the node map of the current graph homomorphism */
+static ir_node **node_map;
+/** the edge map of the current graph homomorphism */
+static ir_edge_t **edge_map;
+
+static ir_node  **positive_node_map;
+static ir_edge_t **positive_edge_map;
+
+/* the current match object */
+static ext_grs_match_t *match = NULL;
+/* private data of the current irg */
+static ext_grs_irg_private_t *pr_g = NULL;
+/* the list of already found matches (to be copied into the
+ * match object at the end of the matching process) */
+static struct ext_grs_match_list_head match_list_head;
+
+
+/* an obstack needed by the match dumper */
+static struct obstack dump_obst;
+/* the hash table needed in the dump process mentioned above */
+static lc_pset *dump_node_map, *dump_edge_map;
+/* the number of matches in the match which is currently dumped */
+static int dump_n_matches;
+
+
+
+
+
+
+
+int matched_graph_elem_cmp_func(const void *o1, const void *o2) {
+       ext_grs_matched_graph_elem_t *e1, *e2;
+       e1 = (ext_grs_matched_graph_elem_t *) o1;
+       e2 = (ext_grs_matched_graph_elem_t *) o2;
+
+       assert (e1->kind == e2->kind);
+
+       return (((unsigned) e1->elem.irn) - ((unsigned) e2->elem.irn));
+}
+
+int dump_matched_node_vcgattr(FILE *F, ir_node *node, ir_node *local) {
+
+       ext_grs_matched_graph_elem_t *elem = alloca(sizeof(*elem));
+
+       /* check wether the given node is matched or not */
+       elem->kind = ext_grs_k_node;
+       elem->elem.irn = node;
+       elem = lc_pset_find(dump_node_map, elem, HASH_PTR(node));
+       /* if it is matched... */
+       if (elem) {
+               fprintf (F, "color: magenta");
+               return 1;
+       }
+       return 0;
+}
+
+int dump_matched_edge_vcgattr(FILE *F, ir_node *node, int to) {
+
+       ext_grs_matched_graph_elem_t *elem = alloca(sizeof(*elem));
+
+       const ir_edge_t *edge =  get_irn_edge(get_irn_irg(node), node, to);
+
+       /* check whether the given node is matched or not */
+       elem->kind = ext_grs_k_edge;
+       elem->elem.ire = edge;
+       elem = lc_pset_find(dump_edge_map, elem, HASH_PTR(edge));
+       /* if it is matched... */
+       if (elem) {
+               fprintf (F, "color:magenta");
+               return 1;
+       }
+       return 0;
+}
+
+int dump_graph_match_nodes(FILE *F, ir_graph *irg) {
+
+       int which;
+       for (which = 0; which < dump_n_matches; which++) {
+               fprintf(F, "node: {title: \"match%d\" label: \"Match %d\" ", which, which);
+               fprintf(F, "color: cyan}\n");
+       }
+
+       return 0;
+}
+
+int dump_match_edges(FILE *F, ir_node *node) {
+
+       ext_grs_matched_graph_elem_t *elem = alloca(sizeof(*elem));
+       int which;
+       lc_list_t *pos;
+
+       /* check wether the given node is matched or not */
+       elem->kind = ext_grs_k_node;
+       elem->elem.irn = node;
+       elem = lc_pset_find(dump_node_map, elem, HASH_PTR(node));
+       /* if it is matched... */
+       if (elem)
+               for (which = 0; which < dump_n_matches; which++)
+                       if (elem->matched[which])
+                               lc_list_for_each (pos, & elem->aiids[which]) {
+                                       /* get the index in the node map */
+                                       ext_grs_matched_aiids_t *aiid_wrapper =
+                                               lc_list_entry(pos, ext_grs_matched_aiids_t, list);
+                                       /* gen an edge from match node to matched node */
+                                       fprintf(F, "edge: {sourcename: \"match%d\" targetname: \"", which);
+                                       PRINT_NODEID(node);
+                                       fprintf(F, "\" ");
+                                       fprintf(F, "label: \"%d\" color:cyan}\n", aiid_wrapper->aiid);
+                               }
+
+       return 0;
+}
+
+void ext_grs_dump_match(ext_grs_match_t *match, const char *suffix) {
+
+       int i;
+       int which, aiid;
+       ext_grs_matched_graph_elem_t *elem;
+       ext_grs_matched_aiids_t *aiid_wrapper;
+       DUMP_NODE_EDGE_FUNC remember;
+
+       obstack_init(& dump_obst);
+
+       /* establish hash tables to determine, whether a nodes
+        *  or edges have been matched or not */
+       dump_node_map =
+               lc_pset_new(matched_graph_elem_cmp_func, match->n_nodes * match->n_matches);
+       dump_edge_map =
+               lc_pset_new(matched_graph_elem_cmp_func, match->n_edges * match->n_matches);
+
+       for (which = 0; which < match->n_matches; which++) {
+               for (aiid = 0; aiid < match->n_nodes; aiid ++) {
+
+                       ir_node *irn = match->nodes[which][aiid];
+
+                       elem = alloca(sizeof(*elem));
+                       elem->kind = ext_grs_k_node;
+                       elem->elem.irn = irn;
+                       elem = lc_pset_find(dump_node_map, elem, HASH_PTR(irn));
+
+                       if (!elem) {
+
+                               elem = obstack_alloc(& dump_obst, sizeof(*elem));
+                               elem->matched = obstack_alloc(
+                                       & dump_obst, match->n_matches * sizeof(*elem->matched));
+                               elem->aiids = obstack_alloc(
+                                       & dump_obst, match->n_matches * sizeof(*elem->aiids));
+                               /* init to 'not matched' for each match */
+                               memset(elem->matched, 0, match->n_matches * sizeof(*elem->matched));
+                               /* init the list heads in the aiid array */
+                               for (i = 0; i < match->n_matches; i++)
+                                       LC_INIT_LIST_HEAD( &(elem->aiids[i]) );
+
+                               elem->kind = ext_grs_k_node;
+                               elem->elem.irn = irn;
+                               lc_pset_insert(dump_node_map, elem, HASH_PTR(irn));
+                       }
+                       elem->matched[which] = 1;
+                       aiid_wrapper = obstack_alloc(& dump_obst, sizeof(*aiid_wrapper));
+                       aiid_wrapper->aiid = aiid;
+                       lc_list_add(& aiid_wrapper->list, & (elem->aiids[which]));
+               }
+               for (aiid = 0; aiid < match->n_edges; aiid ++) {
+
+                       const ir_edge_t *ire = match->edges[which][aiid];
+
+                       elem = alloca(sizeof(*elem));
+                       elem->kind = ext_grs_k_edge;
+                       elem->elem.ire = ire;
+                       elem = lc_pset_find(dump_edge_map, elem, HASH_PTR(ire));
+
+                       if (!elem) {
+                               elem = obstack_alloc(& dump_obst, sizeof(*elem));
+                               elem->matched = obstack_alloc(
+                                       & dump_obst, match->n_matches * sizeof(*elem->matched));
+                               elem->aiids = obstack_alloc(
+                                       & dump_obst, match->n_matches * sizeof(*elem->aiids));
+                               /* init to 'not matched' for each match */
+                               memset(elem->matched, 0, match->n_matches * sizeof(*elem->matched));
+                               /* init the list heads in the indices array */
+                               for (i = 0; i < match->n_matches; i++)
+                                       LC_INIT_LIST_HEAD( &(elem->aiids[i]) );
+
+                               elem->kind = ext_grs_k_edge;
+                               elem->elem.ire = ire;
+                               lc_pset_insert(dump_edge_map, elem, HASH_PTR(ire));
+                       }
+                       elem->matched[which] = 1;
+                       aiid_wrapper = obstack_alloc(& dump_obst, sizeof(*aiid_wrapper));
+                       aiid_wrapper->aiid = aiid;
+                       lc_list_add(& aiid_wrapper->list, & (elem->aiids[which]));
+               }
+       }
+
+       /* set some hooks to produce the needed output in the generated vcg file */
+       set_dump_node_vcgattr_hook(dump_matched_node_vcgattr);
+       set_dump_edge_vcgattr_hook(dump_matched_edge_vcgattr);
+       set_dump_ir_graph_hook(dump_graph_match_nodes);
+
+       remember = get_dump_node_edge_hook();
+       set_dump_node_edge_hook(dump_match_edges);
+
+       /* dump the ir graph */
+       dump_n_matches = match->n_matches;
+       dump_ir_graph(match->irg, suffix);
+
+       /* reset the hooks */
+       set_dump_node_vcgattr_hook(NULL);
+       set_dump_edge_vcgattr_hook(NULL);
+       set_dump_ir_graph_hook(NULL);
+       set_dump_node_edge_hook(remember);
+
+       /* delete auxillary data structures */
+       lc_pset_del(dump_node_map);
+       lc_pset_del(dump_edge_map);
+       obstack_free(& dump_obst, NULL);
+       obstack_finish(& dump_obst);
+}
+
+
+
+
+
+/* initialize the matching mechanism */
+void _ext_grs_match_init(void) {
+       /* init the node map */
+       node_map = NEW_ARR_F(ir_node*, 100);
+       memset(node_map, 0, sizeof(*node_map) * 100);
+       /* init the edge map */
+       edge_map = (ir_edge_t **) NEW_ARR_F(ir_edge_t*, 100);
+       memset(edge_map, 0, sizeof(*edge_map) * 100);
+}
+
+
+
+static INLINE void store_match(void) {
+
+       int aiid;
+       ir_node *node;
+       ir_edge_t *edge;
+       struct ext_grs_match_list_head *match_list_elem;
+       ext_grs_iredges_private_t *pr_e;
+
+       int n_all_pattern_nodes = match->action->max_node_aiid + 1;
+       int n_all_pattern_edges = match->action->max_edge_aiid + 1;
+
+       /* allocate new list elem on the match internal obstack */
+       match_list_elem = obstack_alloc(& match->obst, sizeof(*match_list_elem));
+       memset(match_list_elem, 0, sizeof(match_list_elem));
+
+       /* add this new wrapper for the found match to the list */
+       lc_list_add(& match_list_elem->list, & match_list_head.list);
+
+       /* allocate space for the arrays representing the node and edge map */
+       match_list_elem->nodes =
+               obstack_alloc(& match->obst, n_all_pattern_nodes * sizeof(ir_node *));
+       match_list_elem->edges =
+               obstack_alloc(& match->obst, n_all_pattern_edges * sizeof(ir_edge_t *));
+
+       memset(match_list_elem->nodes, 0, n_all_pattern_nodes * sizeof(*match_list_elem->nodes));
+       memset(match_list_elem->edges, 0, n_all_pattern_edges * sizeof(*match_list_elem->edges));
+
+       /* copy node map into match object */
+       for (aiid = 0; aiid < n_all_pattern_nodes; aiid++) {
+
+               ext_grs_node_t *pat_node = match->action->nodes[aiid];
+
+               if (pat_node->graph->kind != ext_grs_k_pattern) continue;
+               node = node_map[aiid];
+
+               assert(node && "a pattern node should have been matched");
+               assert(pat_node->kind == ext_grs_k_node &&
+                       "a pseudo node should not have been matched");
+
+               match_list_elem->nodes[aiid] = node;
+
+               if (match_compliant && match->action->node_critical[aiid])
+                       if (node) {
+                               set_irn_visited(node, irg_visit_phase);
+                               return_to_mop_index =
+                                       return_to_mop_index < match->action->nodes[aiid]->first_mop_index ?
+                                               return_to_mop_index : match->action->nodes[aiid]->first_mop_index;
+                       }
+       }
+
+       /* copy edge map into match object */
+       for (aiid = 0; aiid < n_all_pattern_edges; aiid++) {
+
+               ext_grs_edge_t *pat_edge = match->action->edges[aiid];
+
+               /* check wether the current edge is a not pseudo-edge */
+               if (pat_edge->kind != ext_grs_k_edge) continue;
+               /* check wether the current edge belongs to the pattern graph
+                * (and not to e.g. a negative graph) */
+               if (pat_edge->graph->kind != ext_grs_k_pattern) continue;
+
+               edge = edge_map[aiid];
+
+               assert(edge && "a pattern edge should have been matched");
+               assert(pat_edge->kind == ext_grs_k_edge &&
+                       "a pseudo edge should not have been matched");
+
+               match_list_elem->edges[aiid] = edge;
+
+               if (match_compliant && match->action->edge_critical[aiid]) {
+
+                       pr_e = get_edge_private_data(edge, _ext_grs_private_ofs_e);
+                       pr_e->visited = irg_visit_phase;
+                       return_to_mop_index =
+                               return_to_mop_index < match->action->edges[aiid]->first_mop_index ?
+                                       return_to_mop_index : match->action->edges[aiid]->first_mop_index;
+               }
+       }
+
+       /* increment counter for the found matches */
+       match->n_matches++;
+}
+
+static void fill_match_result(ext_grs_match_plan_t *plan) {
+
+       int match_counter = 0;
+       struct ext_grs_match_list_head *list_elem;
+
+       ext_grs_match_t *restore_match;
+       ext_grs_match_t *neg_match;
+
+       lc_list_t *pos;
+
+       /* allocate space for the two arrays containing the node and edge maps */
+       match->nodes = obstack_alloc(& match->obst, match->n_matches * sizeof(*match->nodes));
+       match->edges = obstack_alloc(& match->obst, match->n_matches * sizeof(*match->edges));
+       match->repl_nodes = obstack_alloc(& match->obst, match->n_matches * sizeof(*match->repl_nodes));
+
+       restore_match = match;
+       neg_match = alloca(sizeof(*neg_match));
+
+       /* init that match object */
+
+
+       /* store the node and edge maps */
+       match_counter = 0;
+       /* Walk through the list of matches */
+       lc_list_for_each(pos, & match_list_head.list) {
+               int i;
+               lc_list_t *neg_pattern_list;
+
+               list_elem = lc_list_entry(pos, struct ext_grs_match_list_head, list);
+
+               /* for the current positive match ensure that no NAC occurs in the host graph */
+               match = neg_match;
+               neg_pattern_list = &plan->action->negatives;
+               neg_pattern_list = neg_pattern_list->next;
+               /* act->negatives is the list head, call next node to find the first object in list */
+               for(i = 1; i < plan -> num_progs; i++)
+               {
+                       ext_grs_graph_t *pat = lc_list_entry(neg_pattern_list, ext_grs_graph_t, negative_list);
+
+                       memset(match, 0, sizeof(*neg_match));
+                       match->n_nodes = pat->n_nodes;
+                       match->n_edges = pat->n_edges;
+                       match->action = plan->action;
+                       match->irg = restore_match->irg;
+                       match->max_node_id = plan->action->max_node_aiid;
+                       match->max_edge_id = plan->action->max_edge_aiid;
+                       match->compliant = ext_grs_REGARDLESS;
+
+
+                       return_to_mop_index = plan->length[i] - 1;
+                       length = plan->length[i];
+                       prog = plan->progs[i];
+                       mpos = 0;
+                       match_negative_pattern = 1;
+                       found_negative = 0;
+                       match_compliant = 0;
+                       max_n_matches = 1;
+                       positive_node_map = list_elem->nodes;
+                       positive_edge_map = list_elem->edges;
+
+                       /* if program has length 0 ... do nothing */
+                       if(plan->length[i] <= 0)
+                               break;
+
+                       match_rec();
+                       if(found_negative == 1)
+                               break;
+                       neg_pattern_list = neg_pattern_list->next;
+               }
+               match_negative_pattern = 0;
+               match = restore_match;
+
+               if(found_negative == 1)
+                       continue;
+
+
+               match->nodes[match_counter] = list_elem->nodes; /* node_map */
+               match->edges[match_counter] = list_elem->edges; /* edge_map */
+
+               match_counter++;
+       }
+       /* Some positive matches could have been eliminated due to NAC's,
+          so adapt number of matches */
+       match->n_matches = match_counter;
+       assert(match_counter <= match->n_matches && "wrong number of matches stored");
+}
+
+
+
+/* ---------------
+   What does this?
+   --------------- */
+static INLINE int match_preset_rec(
+        ext_grs_node_t *pattern_node, ext_grs_match_op_t *current_mop, ir_node *host_node)
+{
+       ext_grs_irn_private_t *pr_n;
+       ext_grs_node_t *alredy_matched_pattern_node;
+
+       /* Get the private ir data of the host node */
+       pr_n = get_irn_data(host_node, ext_grs_irn_private_t, _ext_grs_private_ofs_n);
+
+       assert(pattern_node->mode == mode_ANY || get_irn_mode(host_node) == pattern_node->mode);
+
+       assert(get_irn_opcode(host_node) == get_op_code(pattern_node->op) ||
+               _ext_grs_OP_IS_A(get_irn_opcode(host_node),     get_op_code(pattern_node->op))
+       );
+
+       assert(
+               match->action->node_critical[pattern_node->aiid] == 0 ||
+               match->action->node_critical[pattern_node->aiid] == 1
+       );
+
+       assert(!pr_n->deleted &&
+               "a node deleted by a rewrite step should not be a member of a node list");
+
+       /* if pattern is negative, compliant matching makes no sense */
+       assert(! (match_compliant && match_negative_pattern));
+
+       if (match_compliant && match->action->node_critical[pattern_node->aiid]) {
+               assert(get_irn_visited(host_node) <= irg_visit_phase &&
+                       "visited in a future phase?");
+               if (get_irn_visited(host_node) == irg_visit_phase) return;  // TODO! Return a value here!
+       }
+
+       /* check whether the current host graph node has not already
+       * been matched. But if it has, the according host nodes have
+       * to be allowed to be matched homomorphic with the current
+       * host node */
+       alredy_matched_pattern_node = pr_n->preimage;
+       if (alredy_matched_pattern_node == NULL ||
+               match->action->hom[pattern_node->aiid][alredy_matched_pattern_node->aiid])
+       {
+
+               /* if the host node has NOT already been matched before
+               * remember the pattern node as already matched to the host node */
+               int matched_first = 0;
+               if (alredy_matched_pattern_node == NULL) {
+                       matched_first = 1;
+               }
+
+               pr_n->preimage = pattern_node;
+
+               /* add the pair (pattern_node, host_node) to the node map */
+               node_map[pattern_node->aiid] = host_node;
+
+
+
+               /* check the condition if present */
+               if (!current_mop->condition || current_mop->condition(node_map, edge_map)) {
+                       /* call recursively to process the next matcher op */
+                       mpos++;
+                       match_rec();
+                       mpos--;
+               }
+
+
+               /* remove the pair (pattern_node, host_node) from the node map */
+               node_map[pattern_node->aiid] = NULL;
+               /* remember whether this matching is no more */
+
+
+               /* if the pattern node was the first node to be matched with
+               * the host node,  */
+               if (matched_first)
+                       pr_n->preimage = NULL;
+
+               /* check whether matching is already complete */
+               if (match->n_matches == max_n_matches) return 1;
+               assert(match->n_matches < max_n_matches || max_n_matches == -1);
+               /* check whether backjumping is needed
+               * (this only happens for compliant matching) */
+               if (return_to_mop_index < mpos) return 1;
+               return_to_mop_index = length - 1;
+       }
+
+
+       /* matching not yet complete (or no backjumping needed),
+       * do more matching if possible */
+       return 0;
+}
+
+
+static INLINE int match_node_rec(
+       ext_grs_node_t *pattern_node, ext_grs_match_op_t *current_mop, ir_opcode opc, modecode mc)
+{
+       lc_list_t *node_list_head = & _ext_grs_NODE_LIST(pr_g, opc, mc);
+       lc_list_t *pos;
+       ir_node *host_node;
+
+       /* FOR all ir nodes in the node list of the current op
+        * and the pattern nodes mode DO... */
+       /* In other words: Start a new match for each host-node with the current op. (Backtracking) */
+
+       lc_list_for_each (pos, node_list_head) {
+
+               ext_grs_irn_private_t *pr_n;
+               ext_grs_node_t *alredy_matched_pattern_node;
+
+#if DUMP_WHILE_MATCHING
+               printf("Next node...\n");
+#endif
+
+               pr_n = lc_list_entry(pos, ext_grs_irn_private_t, node_list);
+               host_node = get_irn_data_base(pr_n, _ext_grs_private_ofs_n);
+
+               assert(pattern_node->mode == mode_ANY || get_irn_mode(host_node) == pattern_node->mode);
+
+               assert(get_irn_opcode(host_node) == get_op_code(pattern_node->op) ||
+                       _ext_grs_OP_IS_A(
+                                       get_irn_opcode(host_node),
+                                       get_op_code(pattern_node->op)
+                               )
+               );
+
+               assert(
+                       match->action->node_critical[pattern_node->aiid] == 0 ||
+                       match->action->node_critical[pattern_node->aiid] == 1);
+
+               assert(!pr_n->deleted &&
+                       "a node deleted by a rewrite step should not be a member of a node list");
+
+               if (match_compliant && match->action->node_critical[pattern_node->aiid]) {
+                       assert(get_irn_visited(host_node) <= irg_visit_phase &&
+                               "visited in a future phase?");
+                       if (get_irn_visited(host_node) == irg_visit_phase) continue;
+               }
+
+               /* check whether the current host graph node has not already
+                * been matched. But if it has, the according host nodes have
+                * to be allowed to be matched homomorphic with the current
+                * host node */
+               alredy_matched_pattern_node = pr_n->preimage;
+               if (alredy_matched_pattern_node == NULL ||
+                       match->action->hom[pattern_node->aiid][alredy_matched_pattern_node->aiid])
+               {
+
+                       /* if the host node has NOT already been matched before
+                        * remember the pattern node as already matched to the host node */
+                       int matched_first = 0;
+                       if (alredy_matched_pattern_node == NULL) {
+                               matched_first = 1;
+                       }
+
+                       pr_n->preimage = pattern_node;
+
+                       /* add the pair (pattern_node, host_node) to the node map */
+                       node_map[pattern_node->aiid] = host_node;
+
+                       /* check the condition if present */
+                       if (!current_mop->condition || current_mop->condition(node_map, edge_map)) {
+                                       /* call recursively to process the next matcher op */
+                                       mpos++;
+                                       match_rec();
+                                       mpos--;
+                               }
+
+
+
+                       /* remove the pair (pattern_node, host_node) from the node map */
+                       node_map[pattern_node->aiid] = NULL;
+                       /* remember whether this matching is no more */
+
+
+                       /* if the pattern node was the first node to be matched with
+                        * the host node,  */
+                       if (matched_first)
+                               pr_n->preimage = NULL;
+
+                       /* check whether matching is already complete */
+                       if (match->n_matches == max_n_matches) return 1;
+                       assert(match->n_matches < max_n_matches || max_n_matches == -1);
+                       /* check whether backjumping is needed
+                        * (this only happens for compliant matching) */
+                       if (return_to_mop_index < mpos) return 1;
+                       return_to_mop_index = length - 1;
+               }
+       }
+       /* matching not yet complete (or no backjumping needed),
+        * do more matching if possible */
+       return 0;
+}
+
+
+
+static void match_edge_rec(
+       ext_grs_node_t *pattern_node,
+       ext_grs_edge_t *pattern_edge,
+       ext_grs_node_t *other_pattern_node,
+       ir_node *host_node, ir_edge_t *host_edge, ir_node *other_host_node)
+{
+
+       ext_grs_irn_private_t *pr_n;
+       ext_grs_iredges_private_t *pr_e =
+               get_edge_private_data(host_edge, _ext_grs_private_ofs_e);
+
+       int matched_first = 0;
+       int both_nodes_matched = 0;
+       ext_grs_edge_t *already_matched_pattern_edge;
+       ext_grs_node_t *already_matched_other_pattern_node;
+
+#if DUMP_WHILE_MATCHING
+       printf("%d: Checking %s%d -> %s%d (%s->%s) (%s->%s)\n", mpos, get_op_name(get_irn_op(host_node)), host_node->node_nr, get_op_name(get_irn_op(other_host_node)), other_host_node->node_nr, get_op_name(pattern_node->op), get_op_name(other_pattern_node->op), pattern_node->name, other_pattern_node->name);
+#endif
+
+       assert(
+               match->action->edge_critical[pattern_edge->aiid] == 0 ||
+               match->action->edge_critical[pattern_edge->aiid] == 1);
+
+       /* if node has already been delted on a rewrite step and it still reached
+        * (maybe by a matching comming from the igrs Bad node) it is nevertheless
+        * NOT matched! */
+       pr_n = _ext_grs_get_irn_private(other_host_node);
+       if (pr_n->deleted) {
+               assert(host_node == get_irg_bad(match->irg) &&
+                       "this node has been deleted by a rewrite step, the only chance" &&
+                       "to meet it should have been coming from the irgs bad node");
+               return;
+       }
+
+       if (match_compliant) {
+               if (match->action->edge_critical[pattern_edge->aiid]) {
+                       assert(pr_e->visited <= irg_visit_phase && "visited in a future phase?");
+                       if (pr_e->visited == irg_visit_phase) return;
+               }
+               if (match->action->node_critical[other_pattern_node->aiid]) {
+                       assert(get_irn_visited(other_host_node) <= irg_visit_phase &&
+                               "visited in a future phase?");
+                       if (get_irn_visited(other_host_node) == irg_visit_phase) return;
+               }
+       }
+       /* check whether the op of the host edge matches
+        * the op of the current pattern edge */
+       if (get_irn_op(other_host_node) != other_pattern_node->op &&
+               ! _ext_grs_OP_IS_A(get_irn_opcode(other_host_node), get_op_code(other_pattern_node->op)))
+               return;
+
+       /* check whether the mode of the node at the other end of the host edge
+        * matches the mode of the pattern node at the other end of the pattern edge */
+       if (
+               /* if the other pattern node allows any mode, dont check the mode
+                * of the other host node at all */
+               other_pattern_node->mode != mode_ANY &&
+               /* otherwise check whether the modecode of the other
+                * pattern and the other host node are equal */
+               other_pattern_node->mode != get_irn_mode(other_host_node)
+       ) return;
+
+       /* check whether the current host edge has not already been matched */
+       already_matched_pattern_edge = pr_e->preimage;
+       if ( already_matched_pattern_edge != NULL ) return;
+
+
+       /* if both pattern nodes have already been matched, check whether the other
+        * host nodes preimage equals the other pattern node */
+       if (node_map[other_pattern_node->aiid] != NULL) {
+               /* in the case that both nodes are already matched check whether the
+                * current host edge connects these nodes */
+               if (node_map[other_pattern_node->aiid] != other_host_node) return;
+               both_nodes_matched = 1;
+       }
+       else {
+               /* if the current host edge is NOT loop... */
+               if (other_host_node != host_node) {
+
+                       /* check whether the host node at the other end of the current
+                        * host edge has not already been matched OR, if it HAS, whether the already
+                        * matched pattern node is permitted to be matched homomorphic with the
+                        * pattern node at the other end of the current pattern edge */
+                       already_matched_other_pattern_node = pr_n->preimage;
+                       if (already_matched_other_pattern_node != NULL) {
+                               if (! match->action->hom
+                                               [other_pattern_node->aiid][already_matched_other_pattern_node->aiid]
+                               ) return;
+                       }
+                       else {
+                               /* if the other host node has not already been matched, this
+                                * is matching is for the first time */
+                               pr_n->preimage = other_pattern_node;
+                               matched_first = 1;
+                       }
+
+                       /* add the pair (other_pattern_node, other_host_node) to the node map */
+                       node_map[other_pattern_node->aiid] = other_host_node;
+               }
+       }
+
+
+       /* add the pair (pattern_edge, host_edge) to the node map */
+       edge_map[pattern_edge->aiid] = host_edge;
+       pr_e->preimage = pattern_edge;
+
+       /* check the condition if present */
+       if (!prog[mpos].condition || prog[mpos].condition(node_map, edge_map)) {
+               /* call recursively to process the next matcher op */
+               mpos++;
+#if DUMP_WHILE_MATCHING
+               printf("found it.\n");
+#endif
+               match_rec();
+               mpos--;
+       }
+#if DUMP_WHILE_MATCHING
+       else if(prog[mpos].condition)
+               printf("Condition failed\n");
+#endif
+
+       /* if the current host edge is NOT loop... */
+       if (! both_nodes_matched)
+               if (other_host_node != host_node) {
+                       /* remove the pair (pattern_node, host_node) from the node map */
+                       node_map[other_pattern_node->aiid] = NULL;
+               }
+       edge_map[pattern_edge->aiid] = NULL;
+       pr_e->preimage = NULL;
+
+       /* if the pattern node was the first node to be matched with
+        * the host node... */
+       if (matched_first)
+               pr_n->preimage = NULL;
+}
+
+
+
+
+
+
+
+
+
+
+static void match_preset_edge_rec(
+                                                  ext_grs_node_t *pattern_node,
+                                                  ext_grs_edge_t *pattern_edge,
+                                                  ext_grs_node_t *other_pattern_node,
+
+                                                  ir_node *host_node, ir_edge_t *host_edge, ir_node *other_host_node)
+{
+
+       ext_grs_irn_private_t *pr_n;
+       ext_grs_iredges_private_t *pr_e =
+               get_edge_private_data(host_edge, _ext_grs_private_ofs_e);
+
+       int matched_first = 0;
+       int both_nodes_matched = 0;
+       ext_grs_edge_t *already_matched_pattern_edge;
+       ext_grs_node_t *already_matched_other_pattern_node;
+
+       assert(
+               match->action->edge_critical[pattern_edge->aiid] == 0 ||
+               match->action->edge_critical[pattern_edge->aiid] == 1);
+
+       /* if node has already been deleted on a rewrite step and it still reached
+       * (maybe by a matching coming from the irgs Bad node) it is nevertheless
+       * NOT matched! */
+
+       pr_n = _ext_grs_get_irn_private(other_host_node);
+       if (pr_n->deleted) {
+               assert(host_node == get_irg_bad(match->irg) &&
+                       "this node has been deleted by a rewrite step, the only chance" &&
+                       "to meet it should have been coming from the irgs bad node");
+               return;
+       }
+
+       if (match_compliant) {
+               if (match->action->edge_critical[pattern_edge->aiid]) {
+                       assert(pr_e->visited <= irg_visit_phase && "visited in a future phase?");
+                       if (pr_e->visited == irg_visit_phase) return;
+               }
+               if (match->action->node_critical[other_pattern_node->aiid]) {
+                       assert(get_irn_visited(other_host_node) <= irg_visit_phase &&
+                               "visited in a future phase?");
+                       if (get_irn_visited(other_host_node) == irg_visit_phase) return;
+               }
+       }
+       /* check wether the op of the host edge matches
+       * the op of the current pattern edge */
+       if (
+               get_irn_op(other_host_node) != other_pattern_node->op &&
+               ! _ext_grs_OP_IS_A(get_irn_opcode(other_host_node), get_op_code(other_pattern_node->op))
+               ) return;
+
+       /* check wether the mode of the node at the other end of the host edge
+       * matches the mode of the pattern node at the other end of the pattern edge */
+       if (
+               /* if the other pattern node allows any mode, dont check the mode
+               * of the other host node at all */
+               other_pattern_node->mode != mode_ANY &&
+               /* otherwise check wether the modecode of the other
+               * pattern and the other host node are equal */
+               other_pattern_node->mode != get_irn_mode(other_host_node)
+               ) return;
+
+       /* check wether the current host edge has not already been matched */
+       already_matched_pattern_edge = pr_e->preimage;
+       if ( already_matched_pattern_edge != NULL ) return;
+
+
+       /* if both pattern nodes have already been matched, check wether the other
+       * host nodes preimage equals the other pattern node */
+       if (node_map[other_pattern_node->aiid] != NULL) {
+               /* in the case that both nodes are already matched check wether the
+               * current host edge connects these nodes */
+               if (node_map[other_pattern_node->aiid] != other_host_node) return;
+               both_nodes_matched = 1;
+       }
+       else {
+               /* if the current host edge is NOT loop... */
+               if (other_host_node != host_node) {
+
+                       /* check wether the host node at the other end of the current
+                       * host edge has not alredy been matched OR, if it HAS, wether the already
+                       * matched pattern node is permitted to be matched homomorphic with the
+                       * pattern node at the other end of the current pattern edge */
+                       already_matched_other_pattern_node = pr_n->preimage;
+                       if (already_matched_other_pattern_node != NULL) {
+                               if (! match->action->hom
+                                       [other_pattern_node->aiid][already_matched_other_pattern_node->aiid]
+                               ) return;
+                       }
+                       else {
+                               /* if the other host node has not already been matched, this
+                               * is matching is for the first time */
+                               pr_n->preimage = other_pattern_node;
+                               matched_first = 1;
+                       }
+
+                       /* add the pair (other_pattern_node, other_host_node) to the node map */
+                       node_map[other_pattern_node->aiid] = other_host_node;
+               }
+       }
+
+
+       /* add the pair (pattern_edge, host_edge) to the node map */
+       edge_map[pattern_edge->aiid] = host_edge;
+       pr_e->preimage = pattern_edge;
+
+       /* check the condition if present */
+       if (!prog[mpos].condition || prog[mpos].condition(node_map, edge_map)) {
+               /* call recursively to process the next matcher op */
+               mpos++;
+               match_rec();
+               mpos--;
+       }
+
+       /* if the current host edge is NOT loop... */
+       if (! both_nodes_matched)
+               if (other_host_node != host_node) {
+                       /* remove the pair (pattern_node, host_node) from the node map */
+                       node_map[other_pattern_node->aiid] = NULL;
+               }
+               edge_map[pattern_edge->aiid] = NULL;
+               pr_e->preimage = NULL;
+
+               /* if the pattern node was the first node to be matched with
+               * the host node... */
+               if (matched_first)
+                       pr_n->preimage = NULL;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* The matching loop, actually recursive but implemented as
+ * while loop by using a (only conceptually existing) stack.
+ * The stack is not implicitly materialized by appropriate
+ * fields present in the match op structs.
+ * */
+static void match_rec(void) {
+
+       ext_grs_match_op_t *current_mop = NULL;
+
+       ext_grs_edge_t *pattern_edge = NULL;
+       ext_grs_node_t *pattern_node = NULL;
+       ext_grs_node_t *other_pattern_node = NULL;
+
+       ir_node *host_node = NULL;
+       ir_node *other_host_node = NULL;
+       ir_edge_t *host_edge = NULL;
+
+
+       assert(prog != NULL && "global ptr to matcher program is NULL");
+
+       /* if the hole match prog has been processed... */
+       if (mpos >= length) {
+               /* ...a complete match has been found */
+               /* so add this complete match to the match object */
+
+               if(match_negative_pattern == 0)
+                       store_match();
+               else
+               {
+                       found_negative = 1;
+                       match->n_matches = 1;
+               }
+               return;
+       }
+
+       current_mop = & prog[mpos];
+       /* execute the current match op */
+       /* if the current match op is a node-op... */
+
+       if(current_mop->kind == ext_grs_k_mop_preset)
+       {
+               /* loop counters */
+               ir_op *current_op;
+               ir_mode *current_mode;
+               ir_opcode opc;
+               modecode mc;
+
+               int matching_complete_or_backjump;
+
+               pattern_node = current_mop->node;
+               current_mode = pattern_node->mode;
+
+               host_node = positive_node_map[pattern_node->related_node->aiid];
+               current_op = host_node->op;
+
+               /* Pattern_node == NAC node */
+               assert(pattern_node->related_node != NULL && "preset node is not related!!");
+
+               opc = get_op_code(current_op);
+               mc  = get_mode_modecode(current_mode);
+
+
+               /* if there is an op condition, check whether it holds */
+               if (current_mop->op_condition && !current_mop->op_condition(current_op)) return;
+
+               /* if there is an mode condition, check whether it holds */
+               if (current_mop->mode_condition && !current_mop->mode_condition(current_mode)) return;
+
+               matching_complete_or_backjump =
+                       match_preset_rec(pattern_node, current_mop, host_node);
+
+               if (matching_complete_or_backjump) return;
+
+               return;
+       }
+       else if(current_mop->kind == ext_grs_k_mop_preset_edge)
+       {
+               ir_edge_t *host_edge;
+               ir_graph *irg = match->irg;
+
+               pattern_edge = current_mop->edge;
+               pattern_node = current_mop->node;
+
+               /* check  whether the given pattern node is incident to the given pattern edge */
+               assert(pattern_node == pattern_edge->func || pattern_node == pattern_edge->arg);
+
+               host_edge = positive_edge_map[pattern_edge->related_edge->aiid];
+               edge_map[pattern_edge->aiid] = host_edge;
+               if(current_mop->condition && !current_mop->condition(node_map, edge_map))
+               {
+                       mpos++;
+                       match_rec();
+                       mpos--;
+               }
+
+       }
+       else if (current_mop->kind == ext_grs_k_mop_node) {
+
+               /* loop counters */
+               int i,j;
+               int n_sub_ops;
+               /* inheritance related stuff */
+               ir_op **sub_op_array;
+               pattern_node = current_mop->node;
+
+
+               sub_op_array = _ext_grs_all_sub_ops_of_op[ get_op_code(pattern_node->op) ];
+               n_sub_ops = ARR_LEN(sub_op_array);
+
+               /* FOR all sub ops of the pattern nodes op DO... */
+               /* Find all nodes in the host graph that have the same op or a sub_op as the pattern node: */
+               for (i = 0; i < n_sub_ops; i++) {
+
+                       ir_op *current_op = sub_op_array[i];
+                       ir_mode *current_mode = pattern_node->mode;
+                       ir_opcode opc = get_op_code(current_op);
+                       modecode mc = get_mode_modecode(current_mode);
+
+                       int matching_complete_or_backjump;
+
+                       /* if there is an op condition, check whether it holds */
+                       if (current_mop->op_condition && !current_mop->op_condition(current_op)) continue;
+
+                       /* if pattern nodes mode is ANY match for ALL modes */
+                       if (current_mode == mode_ANY) {
+                               for (j = 0; j <= _ext_grs_max_modecode; j++) {
+                                       /* if no mode condition present, simply perform matching */
+                                       if (
+                                               current_mop->mode_condition &&
+                                               !current_mop->mode_condition(_ext_grs_mode_map[j])
+                                       ) continue; /* ??? */
+
+                                       /* Start backtracking for all nodes in the host graph that have the current mop */
+                                       matching_complete_or_backjump =
+                                               match_node_rec(pattern_node, current_mop, opc, j);
+
+                                       if (matching_complete_or_backjump) return;
+                               }
+                       }
+                       else {
+                               /* Even theres only ONE possible mode, the mode condition has to
+                                * be checked all the same! E.g. the user may have registered a
+                                * mode condition function which depends on a global state... */
+                               if (
+                                       current_mop->mode_condition &&
+                                       ! current_mop->mode_condition(current_mode) /* <<<  NOT may be WRONG!!!! */
+                               ) continue;
+
+                               matching_complete_or_backjump =
+                                       match_node_rec(pattern_node, current_mop, opc, mc);
+
+                               if (matching_complete_or_backjump) return;
+                       }
+
+               }
+               return;
+       }
+       else if (current_mop->kind == ext_grs_k_mop_edge) {
+
+               ir_graph *irg = match->irg;
+
+               pattern_edge = current_mop->edge;
+               pattern_node = current_mop->node;
+
+               /* check  whether the given pattern node is incident to the given pattern edge */
+               assert(pattern_node == pattern_edge->func || pattern_node == pattern_edge->arg);
+
+
+
+               /* if the pattern edge is an outgoing (i.e. in-flow) edge... */
+               if (pattern_node == pattern_edge->func) {
+
+                       int i = -1; /* -1 for the block edge */
+                       int upper_pos_bound;
+
+                       assert(node_map[pattern_node->aiid] != NULL &&
+                               "this node should have been matched already");
+
+                       other_pattern_node = pattern_edge->arg;
+                       host_node = node_map[pattern_node->aiid];
+
+                       /* only Block nodes have NO block edge (i.e. an edge at pos = -1) */
+                       if (get_irn_op(host_node) == op_Block) i = 0;
+
+                       /* if the current pattern edge gives a fixed edge pos... */
+                       upper_pos_bound = get_irn_arity(host_node);
+                       if (pattern_edge->pos != ext_grs_NO_EDGE_POS) {
+                               /* ...then we do NOT have to iterate over the edges.
+                                * Instead of that we can access and check the host edge directly: */
+                               i = pattern_edge->pos;
+                               upper_pos_bound = i + 1;
+                       }
+
+                       /* FOR all outgoing (i.e. in-flow) edges of the pattern
+                        * nodes current image DO */
+                       for ( ; i < upper_pos_bound; i++) {
+
+                               other_host_node = get_irn_n(host_node, i);
+                               host_edge = get_irn_edge(irg, host_node, i);
+
+                               /* if theres no such edge this is no valid match */
+                               if (! host_edge) continue;
+
+                               match_edge_rec(
+                                       pattern_node, pattern_edge, other_pattern_node,
+                                       host_node, host_edge, other_host_node);
+
+                               if (match->n_matches == max_n_matches) return;
+                               assert(match->n_matches < max_n_matches || max_n_matches == -1);
+
+                               if (return_to_mop_index < mpos) return;
+                               return_to_mop_index = length - 1;
+
+                       }
+                       return;
+               }
+
+               /* or an incoming (i.e. out-flow) edge otherwise */
+               else {
+
+                       assert(pattern_node == pattern_edge->arg &&
+                               "pattern node not incident to pattern edge");
+
+                       assert(node_map[pattern_node->aiid] != NULL &&
+                               "this node should have been matched already");
+
+                       other_pattern_node = pattern_edge->func;
+                       host_node = node_map[pattern_node->aiid];
+
+                       foreach_out_edge(host_node, host_edge) {
+                               int edg_src_pos;
+
+                               /* if the pattern edge determines a fixed pos as outgoing
+                                * (i.e. in-flow) edge  of its func node, check wether the
+                                * pos of the current edge does equal this determined pos */
+                               if (pattern_edge->pos != ext_grs_NO_EDGE_POS &&
+                                       (edg_src_pos = get_edge_src_pos(host_edge)) != pattern_edge->pos)
+                                       continue;
+
+                               other_host_node = get_edge_src_irn(host_edge);
+
+                               match_edge_rec(
+                                       pattern_node, pattern_edge, other_pattern_node,
+                                       host_node, host_edge, other_host_node);
+
+                               if (match->n_matches == max_n_matches) return;
+                               assert(match->n_matches < max_n_matches || max_n_matches == -1);
+
+                               if (return_to_mop_index < mpos) return;
+                               return_to_mop_index = length - 1;
+
+                       }
+                       return;
+
+
+               }
+
+
+       }
+       else {
+               assert(current_mop->kind == ext_grs_k_mop_condition);
+               assert(current_mop->condition && "a conditon mop should have a condition function");
+
+               /* check the condition */
+               if ( ! current_mop->condition(node_map, edge_map) ) return ;
+
+               /* call recursively to process the next matcher op */
+               mpos++;
+               match_rec();
+               mpos--;
+
+               return;
+       }
+
+}
+
+ext_grs_match_t *ext_grs_match(
+       ir_graph *irg, ext_grs_match_plan_t *plan, int n, int compliant)
+{
+       ext_grs_graph_t *pattern = plan->action->pattern;
+
+       if (!irg) {
+               printf("module ext/grs: WARNING in function ext_grs_match()\n");
+               printf("  Given ir graph was NULL.\n\n");
+               return NULL;
+       }
+
+       if (!plan) {
+               printf("module ext/grs: WARNING in function ext_grs_match()\n");
+               printf("  Given match plan was NULL.\n\n");
+               return NULL;
+       }
+
+       /* get the private_data of the current irg */
+       pr_g = _ext_grs_get_irg_private(irg);
+
+       if (!pr_g->matching_enabled) {
+               printf("module ext/grs: ERROR in function ext_grs_match()\n");
+               printf("  Matching is disabeled for the given irg.\n\n");
+               return NULL;
+       }
+
+       /* allocate a new match object */
+       match = (ext_grs_match_t *) malloc(sizeof(*match));
+       if (match == NULL)
+               return NULL;
+       memset(match, 0, sizeof(*match));
+       /* init that match object */
+       match->action = plan->action;
+       match->irg = irg;
+       match->n_nodes = pattern->n_nodes;
+       match->n_edges = pattern->n_edges;
+       match->max_node_id = plan->action->max_node_aiid;
+       match->max_edge_id = plan->action->max_edge_aiid;
+       match->compliant = compliant;
+
+       /* initialize this match's internal obstack */
+       obstack_init(& match->obst);
+
+       /* if program has length 0 just return an empty match */
+       if(plan->length[0] <= 0 || n == 0) {
+               match->n_matches = 0;
+               return match;
+       }
+
+       /* ..................... WHAT DOES THE FOLLOWING???? ............................. */
+
+
+       max_n_matches = n;
+       match_compliant = compliant;
+
+       irg_visit_phase = get_irg_visited(irg) + 1;
+       set_irg_visited(irg, irg_visit_phase);
+
+       /* if node map is not great enough extend it */
+#if 0
+       old_size = ARR_LEN(node_map);
+       ARR_EXTO(ir_node*, node_map, match->action->max_node_aiid + 1);
+       /* if array resized reset it to '0' */
+       if (old_size < ARR_LEN(node_map))
+               memset(node_map, 0, sizeof(*node_map) * ARR_LEN(node_map));
+       /* if edge map is not great enough extend it */
+       old_size = ARR_LEN(edge_map);
+       ARR_EXTO(ir_edge_t*, edge_map, match->action->max_edge_aiid + 1);
+       /* if array resized reset it to '0' */
+       if (old_size < ARR_LEN(edge_map))
+               memset(edge_map, 0, sizeof(*edge_map) * ARR_LEN(edge_map));
+#endif
+
+       node_map = (ir_node **) alloca((match->action->max_node_aiid + 1) * sizeof(*node_map));
+       memset(node_map, 0, sizeof(*node_map) * (match->action->max_node_aiid + 1));
+       edge_map = (ir_edge_t **) alloca((match->action->max_edge_aiid + 1) * sizeof(*edge_map));
+       memset(edge_map, 0, sizeof(*edge_map) * (match->action->max_edge_aiid + 1));
+
+
+       /* init the list of found matches */
+       LC_INIT_LIST_HEAD(& match_list_head.list);
+
+       /* .................................................................................... */
+
+       /* execute the search plan */
+       return_to_mop_index = plan->length[0] - 1;
+       length = plan->length[0];
+       prog = plan->progs[0];
+       mpos = 0;
+       match_negative_pattern = 0;
+       match_rec();
+
+       /* transfer the found matches to the match result object */
+       fill_match_result(plan);
+
+       pr_g = NULL;
+
+       return match;
+}
+
+static int _get_op_n_args(ir_op *op) {
+
+       switch (op->opar)
+       {
+               case oparity_zero: return 0;
+               case oparity_unary: return 1;
+               case oparity_binary: return 2;
+               case oparity_trinary: return 3;
+               default: return 0;
+       }
+
+       return 0;
+}
+
+int compute_new_arity(ir_node **node_map, ir_node **repl_node_map, ext_grs_node_t *pat_node, ext_grs_node_t *replace_node, int repl_node_greatest_edge_pos)
+{
+       int n_free_edges = 0;
+       int old_arity =0, new_arity = 0;
+       int k;
+       ir_node *host_node;
+
+
+       /* get the ir node matched by the the pattern node associated with the
+       * current replacement node */
+       host_node = node_map[pat_node->aiid];
+       assert(host_node && "replacement node associated with NULL pattern node");
+       old_arity = get_irn_arity(host_node);
+
+/*     if(host_node->node_nr == 675)
+               printf("found\n"); */
+
+       /* compute the number of free slots in the current
+       * in array (free means NULL or pointing to a Bad node) */
+       for (k = 0; /*(get_irn_opcode(host_node) == iro_Block) ? 0 : -1;*/ k < old_arity; k++) {
+               ir_node *arg = get_irn_n(host_node, k);
+               if (!arg || get_irn_op(arg) == op_Bad)
+                       n_free_edges++;
+       }
+
+
+       if (repl_node_greatest_edge_pos == ext_grs_NO_EDGE_POS) {
+               new_arity = old_arity + replace_node->n_append_edges - n_free_edges; // New arity may also be shorter!
+                       //old_arity + MAX(0, (replace_node->n_append_edges - n_free_edges));
+       }
+       else {
+               assert(repl_node_greatest_edge_pos >= -1 && "invalid edge pos encountered");
+               new_arity = MAX(repl_node_greatest_edge_pos + 1,  old_arity + replace_node->n_append_edges - n_free_edges);
+                  //MAX(repl_node_greatest_edge_pos + 1, old_arity) + MAX(0, (replace_node->n_append_edges - n_free_edges));
+       }
+       // new_arity = MAX(new_arity, _get_op_n_args(replace_node->op));
+       return(new_arity);
+}
+
+
+void ext_grs_finish_match(ext_grs_match_t *match, int n, int *which) {
+
+       ext_grs_action_t *action;
+       ir_node **node_map;
+       const ir_edge_t **edge_map;
+
+       ir_node **repl_node_map;
+       ir_edge_t **repl_edge_map;
+       ir_node *host_node;
+
+       int n_matches;
+       int i, j, k;
+       lc_list_t *pos;
+
+       ir_node *bad;
+       ext_grs_irg_private_t *pr_g;
+       ir_graph *remeber_current_irg = current_ir_graph;
+
+       /* array of positions where the next edge without given pos can be appended, the
+        * index is the replacement aiid of the replacement node the edge is incoming on */
+       int *next_append_pos;
+
+       int *repl_edge_positions;
+       int *repl_node_greatest_edge_pos;
+
+
+       if (!match) {
+               printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+               printf("  Given match object was NULL.\n");
+               printf("  No rewrite has been performed.\n\n");
+               return;
+       }
+
+
+       action = match->action;
+       pr_g = _ext_grs_get_irg_private(match->irg);
+
+       if (!pr_g->matching_enabled && action->kind != ext_grs_k_test) {
+               printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+               printf("  Tried to finish an action which is not of kind test, while\n");
+               printf("  matching has been disabled for the respective ir graph.\n");
+               printf("  This means that some internal data needed in this is no more");
+               printf("  there. So no transformation of the ir graph has been done.\n\n");
+
+               obstack_free(& match->obst, NULL);
+               free(match);
+
+               return;
+       }
+
+       bad = get_irg_bad(match->irg);
+
+       //repl_node_map = alloca(sizeof(*repl_node_map) * (action->max_repl_node_aiid + 1));    Allocated on the obst now to be available after rewrite
+       repl_edge_map = alloca(sizeof(*repl_edge_map) * (action->max_repl_edge_aiid + 1));
+       next_append_pos = alloca(sizeof(*next_append_pos) * (action->max_repl_node_aiid + 1));
+       repl_edge_positions = alloca(sizeof(*repl_edge_positions) * (action->max_repl_edge_aiid + 1));
+       repl_node_greatest_edge_pos =
+               alloca(sizeof(*repl_node_greatest_edge_pos) * (action->max_repl_node_aiid + 1));
+
+       /* if action is a test no replacement will be done */
+       if (action->kind == ext_grs_k_test) n = 0;
+
+       current_ir_graph = match->irg;
+
+       if (n == ext_grs_ALL) {
+               n_matches = match->n_matches;
+       }
+       else if (n >= 0) {
+               if (n > match->n_matches) {
+                       printf("module ext/grs: WARNING in function ext_grs_finish_match()\n");
+                       printf("  Given number of matches (%d) to be replaced exceeds the", n);
+                       printf("  number of matches found (%d).\n\n", match->n_matches);
+                       n_matches = match->n_matches;
+               }
+               else {
+                       n_matches = n;
+               }
+       }
+       else {
+               printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+               printf("  Given number of matches to be replaced is invalid: %d.\n", n);
+               printf("  No rewrite has been performed.\n\n");
+
+               obstack_free(& match->obst, NULL);
+               free(match);
+
+               return;
+       }
+
+       /* parallel rewrites are forbidden for match objects,
+        * which are not prepared for such things */
+       if ( !match->compliant && n_matches > 1 ) {
+               n_matches = 1;
+               printf("module ext/grs: WARNING in function ext_grs_finish_match()\n");
+               printf("  Parallel rewriting was demanded but the given match object\n");
+               printf("  is not compliant. So only ONE match is replaced.\n\n");
+       }
+
+       /* check for empty which array */
+       if (n != ext_grs_ALL && n != 0 && !which) {
+               printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+               printf("  The set of match numbers to be replaced was NULL.\n");
+               printf("  No rewrite has been performed.\n\n");
+
+               obstack_free(& match->obst, NULL);
+               free(match);
+
+               return;
+       }
+
+
+
+       /* perform replacement of several matches */
+       //i = 0;
+       for(i = 0; i < n_matches; i++)
+       {
+               // while (i < n_matches) {
+
+               repl_node_map = obstack_alloc(&(match->obst), sizeof(*repl_node_map) * (action->max_repl_node_aiid + 1)); //)alloca(sizeof(*repl_node_map) * (action->max_repl_node_aiid + 1));
+               memset(repl_node_map, 0, sizeof(*repl_node_map) * (action->max_repl_node_aiid + 1));
+               memset(repl_edge_map, 0, sizeof(*repl_edge_map) * (action->max_repl_edge_aiid + 1));
+
+               /* get the node and edge map of the current match */
+               if (n == ext_grs_ALL) {
+                       match->repl_nodes[i] = repl_node_map;
+                       node_map = match->nodes[i];
+                       edge_map = match->edges[i];
+               }
+               else {
+                       if (which[i] > match->n_matches) {
+                               printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+                               printf("  A given match number exceeds the number of found matches.\n");
+                               printf("  No rewrite is performed for this number.\n\n");
+
+//                             obstack_free(& match->obst, NULL);
+//                             free(match);
+
+                               continue;
+                       }
+                       match->repl_nodes[which[i]] = repl_node_map;
+                       node_map = match->nodes[which[i]];
+                       edge_map = match->edges[which[i]];
+               }
+
+
+
+               /* Before any graph transformations are done...
+                * ...the eval-in functions of the current action are evaluated for
+                * the current node and edge map */
+               lc_list_for_each(pos, &action->listed_evals) {
+                       /* get the current eval descriptor...  */
+                       ext_grs_eval_descr_t *descr =
+                               lc_list_entry(pos, ext_grs_eval_descr_t, eval_list);
+                       /* get the current eval-in function... */
+                       if(descr->eval_in != NULL) // AS
+                       {
+                               ext_grs_eval_in_func_t in_func = descr->eval_in;
+                               /* ...and call it */
+                               descr->data = in_func(node_map, edge_map);
+                       }
+
+               }
+
+
+
+
+
+               /* First: remove all remove edges of the pattern */
+               lc_list_for_each(pos, & action->pattern->edges) {
+
+                       ir_node *n, *in;
+                       int edge_pos;
+                       const ir_edge_t *remove_edge;
+                       ext_grs_edge_t *pattern_edge =
+                               lc_list_entry(pos, ext_grs_edge_t, edge_list);
+
+                       assert(
+                               (
+                                       pattern_edge->kind == ext_grs_k_edge ||
+                                       pattern_edge->kind == ext_grs_k_pseudo_edge
+                               ) && "wrong kind encountered in edge list"
+                       );
+
+                       /* pseudo edges can't be removed (because they are not mapped) */
+                       if (pattern_edge->kind != ext_grs_k_edge) continue;
+                       /* check whether the pattern edge is to be kept */
+                       if (action->pattern_edge_kept[pattern_edge->aiid] >= 0) continue;
+                       remove_edge = edge_map[pattern_edge->aiid];
+
+                       n = get_edge_src_irn(remove_edge);
+                       in = get_irn_n(n, 0);
+                       edge_pos = get_edge_src_pos(remove_edge);
+
+                       if(n->node_nr == 675)
+                               printf("found");
+
+                       /* let the remove_edges src node point to a Bad node, for
+                        * a complete removal is not permitted by the FIRM syntax */
+               set_irn_n(
+                               get_edge_src_irn(remove_edge),
+                               get_edge_src_pos(remove_edge),
+                               bad);
+               }
+
+
+
+
+
+               /* Second: Go through all replacement node, insert the new ones and
+                * retype the kept ones if necessary. Furthermore establish a map
+                * which maps replacement node aiids to ir node pointers. */
+               for (j = 0; j <= action->max_repl_node_aiid; j++) {
+
+                       ext_grs_node_t *replace_node = action->replacement_nodes[j];
+                       ir_node *block = NULL;
+
+                       ir_node **new_in;
+                       int old_arity = 0;
+                       int new_arity;
+
+                       /* private area of a host node */
+                       ext_grs_irn_private_t *pr_n;
+
+                       repl_node_greatest_edge_pos[j] = ext_grs_NO_EDGE_POS;
+
+                       /* check for gaps in the set of aiids */
+                       if (!replace_node) continue;
+
+                       assert (action->replacement_node_kept[j] >= -1 && "invalid entry found");
+
+
+                       /* for the current replacement node determine the positions of the
+                        * outgoing (i.e. inflowing) edges to be newly inserted and the
+                        * greatest pos among the outgoing (i.e. in-flowing) edges of each
+                        * node */
+                       lc_list_for_each (pos, & replace_node->edges[ext_grs_in]) {
+                               ext_grs_edge_t *in_edge = lc_list_entry(pos, ext_grs_edge_t, list[ext_grs_in]);
+
+                               if (in_edge->position_func) {
+                                       int h;
+                                       assert(in_edge->pos == ext_grs_NO_EDGE_POS &&
+                                               "a replacement edge with pos function should not have a fixed position");
+                                       assert(action->replacement_edge_kept[in_edge->aiid] == -1 &&
+                                               "a replacement edge with pos function is supposed to be newly inserted");
+                                       h = in_edge->position_func(in_edge, node_map, edge_map);
+                                       repl_edge_positions[in_edge->aiid] = h;
+                                       repl_node_greatest_edge_pos[j] = MAX(h, repl_node_greatest_edge_pos[j]);
+                               }
+                               else if (in_edge->pos != ext_grs_NO_EDGE_POS) {
+
+                                       /*      Was soll diese Assertion?
+                                               Kept-Edges duerfen keine feste Position haben oder wie?
+                                               Besser: Pruefe die neue Position auf Gleichheit mit der alten!
+
+                                               Warum trat diese Assertion frueher nicht auf? */
+
+                                       /*assert(action->replacement_edge_kept[in_edge->aiid] == -1 &&
+                                               "a replacement edge with fixed position supposed to be newly inserted"); */
+                                       repl_edge_positions[in_edge->aiid] = in_edge->pos;
+                                       repl_node_greatest_edge_pos[j] =
+                                               MAX(in_edge->pos, repl_node_greatest_edge_pos[j]);
+                               }
+                       }
+
+
+                       /* if node is to be newly inserted */
+                       if (action->replacement_node_kept[j] == -1) {
+
+                               ir_opcode opc;
+                               modecode mc;
+
+                               if (repl_node_greatest_edge_pos[j] == ext_grs_NO_EDGE_POS) {
+                                       new_arity = replace_node->n_append_edges;
+                               }
+                               else {
+                                       assert(repl_node_greatest_edge_pos[j] >= -1 && "invalid edge pos encountered");
+                                       new_arity = repl_node_greatest_edge_pos[j] + 1 + replace_node->n_append_edges;
+                               }
+                               new_arity = MAX(new_arity, _get_op_n_args(replace_node->op));
+
+                               /* non Block nodes initially get a Bad block, block nodes a NULL block */
+                               if (replace_node->op != op_Block)
+                                       block = bad;
+                               else
+                                       block = NULL;
+
+                               if (new_arity > 0) {
+                                       new_in = alloca( sizeof(*new_in) * new_arity );
+                                       for (k = 0; k < new_arity; k++)
+                                               new_in[k] = bad;
+                                       /* create a new node */
+                                       host_node = new_ir_node(
+                                                               NULL, match->irg, block,
+                                                               replace_node->op, replace_node->mode,
+                                                               new_arity, new_in);
+                               }
+                               else {
+                                       host_node = new_ir_node(
+                                                               NULL, match->irg, block,
+                                                               replace_node->op, replace_node->mode,
+                                                               0, NULL);
+                               }
+
+                               /* insert the new node in the respective node list */
+                               opc = get_irn_opcode(host_node);
+                               mc = get_irn_modecode(host_node);
+
+                               pr_n = _ext_grs_get_irn_private(host_node);
+                               lc_list_add(&pr_n->node_list, & _ext_grs_NODE_LIST(pr_g, opc, mc));
+                       }
+                       /* otherwise give the already existing node a new op or mode (if necessary) */
+                       else {
+
+                               /* the pattern node associated with the kept replace node */
+                               ext_grs_node_t *pat_node = action->nodes[action->replacement_node_kept[j]];
+                               /* tells whether a preserved node is changed somehow (op or mode) */
+                               int op_or_mode_changed = 0;
+                               int old_arity, new_arity;
+                               ir_node *old_node = NULL;
+
+                               host_node = node_map[pat_node->aiid];
+                               old_arity = get_irn_arity(host_node);
+                               new_arity = compute_new_arity(node_map, repl_node_map, pat_node, replace_node, repl_node_greatest_edge_pos[j]);
+
+#if 0
+                               int n_free_edges = 0;
+
+
+                               /* get the ir node matched by the the pattern node associated with the
+                                * current replacement node */
+                               host_node = node_map[pat_node->aiid];
+                               assert(host_node && "replacement node associated with NULL pattern node");
+                               old_arity = get_irn_arity(host_node);
+
+                               /* compute the number of free slots in the current
+                                * in array (free means NULL or pointing to a Bad node) */
+                               for (k = -1; k < old_arity; k++) {
+                                       ir_node *arg = get_irn_n(host_node, k);
+                                       if (!arg || get_irn_op(arg) == op_Bad)
+                                               n_free_edges++;
+                               }
+
+
+
+                               if (repl_node_greatest_edge_pos[j] == ext_grs_NO_EDGE_POS) {
+                                       new_arity =
+                                               old_arity + MAX(0, (replace_node->n_append_edges - n_free_edges));
+                               }
+                               else {
+                                       assert(repl_node_greatest_edge_pos[j] >= -1 && "invalid edge pos encountered");
+                                       new_arity = MAX(repl_node_greatest_edge_pos[j] + 1, old_arity) +
+                                                                               MAX(0, (replace_node->n_append_edges - n_free_edges));
+                               }
+                               new_arity = MAX(new_arity, _get_op_n_args(replace_node->op));
+#endif
+
+
+
+                               /* change op if necessary */
+                               if ( pat_node->op != replace_node->op || pat_node->mode != replace_node->mode) {
+
+                                       /* if op changes from Block to something else
+                                        * a bad block will be inserted */
+                                       if (get_irn_op(host_node) == op_Block && replace_node->op != op_Block) {
+                                               assert(0 && "Not possible right now");
+                                               set_irn_op(host_node, replace_node->op);
+                                               set_nodes_block(host_node, bad);
+                                       }
+                                       /* if op changes to Block from something else
+                                        * the Block edge will be deleted */
+                                       else if (get_irn_op(host_node) != op_Block && replace_node->op == op_Block) {
+                                               assert(0 && "Not possible right now");
+                                               assert(get_irn_op(host_node) != op_Bad && "nodes op should change");
+                                               set_irn_n(host_node, -1, NULL);
+                                               set_irn_op(host_node, replace_node->op);
+                                       }
+                                       /* simply change the op otherwise */
+                                       else {
+
+                                               ir_node *exchange_node;
+                                               //new_arity = compute_new_arity(node_map, repl_node_map, pat_node, replace_node, repl_node_greatest_edge_pos[j]);
+
+                                               /* if the edges to be inserted require a greater in-array, create one */
+                                               //if (old_arity != new_arity) {
+                                                       new_in = alloca( sizeof(*new_in) * new_arity );
+                                                       for (k = 0; k < new_arity; k++) {
+                                                               if (k < old_arity)
+                                                                       new_in[k] = get_irn_n(host_node, k);
+                                                               else
+                                                                       new_in[k] = bad;
+                                                       }
+                                               //}
+                                               exchange_node = new_ir_node(NULL, current_ir_graph, get_nodes_block(host_node), replace_node->op, replace_node->mode/*get_irn_mode(host_node)*/, new_arity, new_in);
+                                               old_node = host_node;
+                                               exchange(host_node, exchange_node);
+                                               repl_node_map[j] = exchange_node;
+                                               host_node = exchange_node;
+
+                                               //set_irn_op(host_node, replace_node->op);
+                                       }
+                                       /* remember op or mode was changed */
+                                       op_or_mode_changed = 1;
+                               }
+                               else if(old_arity < new_arity)
+                               {
+                                       /* if the edges to be inserted require a greater in-array, create one */
+                                       // op or mode are not changed, we do not need to insert a new node and exchange it
+                                       // This is the case e.g. for Phi, Sync or Block nodes.
+                                       if (old_arity < new_arity) {
+                                               new_in = alloca( sizeof(*new_in) * new_arity );
+                                               for (k = 0; k < new_arity; k++) {
+                                                       if (k < old_arity)
+                                                               new_in[k] = get_irn_n(host_node, k);
+                                                       else
+                                                               new_in[k] = bad;
+                                               }
+                                               /* note: a nodes block is preserved by set_irn_in() */
+                                               set_irn_in(host_node, new_arity, new_in);
+                                       }
+                               }
+#if 0
+                               // This is done by inserting a new node and exchanging now.
+                               /* or change mode if necessary */
+                               if ( pat_node->mode != replace_node->mode ) {
+                                       set_irn_mode(host_node, replace_node->mode);
+                                       /* remember node was changed */
+                                       op_or_mode_changed = 1;
+                               }
+#endif
+
+                               /* if mode or op was changed this node must be
+                                * moved to another node list */
+
+                               /* Lists:        each node contains in its private data the list head of the
+                                                        list he resides in. */
+
+                               if (op_or_mode_changed) {
+
+                                       ir_opcode opc = get_irn_opcode(host_node);
+                                       modecode mc = get_irn_modecode(host_node);
+
+                                       pr_n = _ext_grs_get_irn_private(host_node);
+
+                                       if(old_node == NULL)
+                                       {
+                                               lc_list_move(&pr_n->node_list, & _ext_grs_NODE_LIST(pr_g, opc, mc));
+                                       }
+                                       else
+                                       {
+                                               // exchange was used
+                                               ext_grs_irn_private_t *pr_n_old;
+
+                                               pr_n_old = _ext_grs_get_irn_private(old_node);
+                                               lc_list_add(&pr_n->node_list, & _ext_grs_NODE_LIST(pr_g, opc, mc));
+                                               lc_list_del(&pr_n_old->node_list/*, & _ext_grs_NODE_LIST(pr_g, opc, mc)*/);
+                                       }
+
+                               }
+                       }
+
+                       /* store the pos where the first edge with unspecified pos can be inserted */
+                       for(k = (get_irn_opcode(host_node) == iro_Block) ? 0 : -1; k < get_irn_arity(host_node); k++) {
+                               ir_node *arg = get_irn_n(host_node, k);
+                               if (!arg || get_irn_op(arg) == op_Bad)
+                               {
+                                       next_append_pos[j] = k;
+                                       break; // AS
+                               }
+                       }
+
+                       /* set up the map of replace nodes to host graph nodes */
+                       repl_node_map[replace_node->aiid] = host_node;
+
+                       assert(
+                               (
+                                       get_op_code(get_irn_op(host_node)) == get_op_code(replace_node->op) ||
+                                       _ext_grs_OP_IS_A(
+                                               get_op_code(get_irn_op(host_node)), get_op_code(replace_node->op)
+                                       )
+                               )
+                               && "replace map should map nodes with compatible op");
+               }
+
+
+
+
+
+
+               /* Third: insert all edges not associated with an pattern edge */
+               for (j = 0; j <= action->max_repl_edge_aiid; /* AS n_replacement_edges;*/ j++) {
+
+                       ext_grs_edge_t *replace_edge = action->replacement_edges[j];
+                       ext_grs_node_t *rpl_src_node, *rpl_tgt_node;
+
+                       ir_node *host_src_node, *host_tgt_node;
+
+/*                     if(j == 12)
+                               printf("found!"); */
+
+                       /* there might be gaps in the array, if an potential aiid
+                        * is not assigned to an edge */
+                       if (!replace_edge) continue;
+
+                       /* if edge not to be newly inserted, skip this edge */
+                       if (action->replacement_edge_kept[replace_edge->aiid] >= 0) continue;
+
+                       rpl_src_node = replace_edge->func;
+                       rpl_tgt_node = replace_edge->arg;
+                       host_src_node = repl_node_map[rpl_src_node->aiid];
+                       host_tgt_node = repl_node_map[rpl_tgt_node->aiid];
+
+                       assert(
+                               (
+                                       get_op_code(get_irn_op(host_src_node)) == get_op_code(rpl_src_node->op) ||
+                                       _ext_grs_OP_IS_A(
+                                               get_op_code(get_irn_op(host_src_node)), get_op_code(rpl_src_node->op)
+                                       )
+                               )
+                               && "replace map should map nodes with compatible op");
+
+                       assert(
+                               (
+                                       get_op_code(get_irn_op(host_tgt_node)) == get_op_code(rpl_tgt_node->op) ||
+                                       _ext_grs_OP_IS_A(
+                                               get_op_code(get_irn_op(host_tgt_node)), get_op_code(rpl_tgt_node->op)
+                                       )
+                               )
+                               && "replace map should map nodes with compatible op");
+
+                       /* if the host src (i.e. func) node is a Bad node */
+                       if (get_irn_op(host_src_node) == op_Bad) {
+                               printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+                               printf("  malformed replacement graph: Bad node cannot have an incoming\n");
+                               printf("  edge, edge was not inserted!\n");
+                               continue;
+                       }
+
+                       /* insert and edge with specified position */
+                       if (replace_edge->pos != ext_grs_NO_EDGE_POS) {
+                               if (replace_edge->pos == -1 && get_irn_op(host_tgt_node) != op_Block) {
+                                       printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+                                       printf("  malformed replacement graph: incomming edge has pos -1, but\n");
+                                       printf("  the argument is NOT a Block node! No edge inserted.\n");
+                                       continue;
+                               }
+                               if (replace_edge->pos == -1 && get_irn_op(host_src_node) == op_Block) {
+                                       printf("module ext/grs: ERROR in function ext_grs_finish_match()\n");
+                                       printf("  malformed replacement graph: incomming edge has pos -1, but!\n");
+                                       printf("  the src node is a Block node! No edge inserted.\n");
+                                       continue;
+                               }
+                               set_irn_n(host_src_node, replace_edge->pos, host_tgt_node);
+                       }
+                       /* if no position is specified the edge is inserted to
+                        * free places of the in-array */
+                       else {
+
+                               ir_node *arg;
+                               for (k = next_append_pos[rpl_src_node->aiid]; ; k++) {
+                                       arg = get_irn_n(host_src_node, k);
+                                       if (!arg || get_irn_op(arg) == op_Bad) break;
+                               }
+
+                               assert(k < get_irn_arity(host_src_node) && "append pos exceeds in-array");
+                               set_irn_n(host_src_node, k, host_tgt_node);
+                               next_append_pos[rpl_src_node->aiid] =
+                                               MAX(k, next_append_pos[rpl_src_node->aiid] + 1);
+                       }
+               }
+
+
+               /* Fourth: remove all nodes to be removed and all incident edges */
+               lc_list_for_each(pos, & action->pattern->nodes) {
+
+                       ext_grs_node_t *pat_node =
+                               lc_list_entry(pos, ext_grs_node_t, node_list);
+
+                       /* private area of a host node */
+                       ext_grs_irn_private_t *pr_n;
+
+                       if (pat_node->kind == ext_grs_k_node) {
+
+                               const ir_edge_t *edge;
+                               const ir_edge_t *ne;
+                               ir_node *remove_host_node;
+
+                               /* if node is to be kept it is skiped */
+                               if (action->pattern_node_kept[pat_node->aiid] >= 0) continue;
+                               assert(pat_node->kind == ext_grs_k_node && "no pseudo node expected");
+
+                               /* get the host the pat node is maped to, then remove it */
+                               remove_host_node = node_map[pat_node->aiid];
+                               assert(remove_host_node && "a pattern node should have been matched");
+                               /* all out edges of that node have to be changed that they
+                                * point to the graphs bad node */
+                               foreach_out_edge_safe(remove_host_node, edge, ne) {
+                                       set_irn_n(get_edge_src_irn(edge), get_edge_src_pos(edge), bad);
+                               }
+                               /* all in edges of the remove node have also altered that they point to bad */
+                               for (j = 0; j < get_irn_arity(remove_host_node); j++) {
+                                       set_irn_n(remove_host_node, j, bad);
+                               }
+                               /* remove the node from the node list */
+                               pr_n = _ext_grs_get_irn_private(remove_host_node);
+                               if ( ! pr_n->deleted ) {
+                                       lc_list_del(&pr_n->node_list);
+                                       pr_n->deleted = 1;
+                               }
+                       }
+               }
+
+
+               /* After each graph transformations ...
+                * ...the eval-out functions of the current action are evaluated for
+                * the current node and edge map of the replacement graph biuld during
+                * the graph transforamtion */
+               lc_list_for_each(pos, &action->listed_evals) {
+                       /* get the current eval descriptor...  */
+                       ext_grs_eval_descr_t *descr =
+                               lc_list_entry(pos, ext_grs_eval_descr_t, eval_list);
+                       /* get the current eval-in function... */
+                       if(descr->eval_out != NULL) // AS
+                       {
+                               ext_grs_eval_out_func_t in_func = descr->eval_out;
+                               /* ...and call it */
+                               in_func(repl_node_map, repl_edge_map, node_map, descr->data);
+                       }
+               }
+
+               //i++;
+
+       }
+       current_ir_graph = remeber_current_irg;
+}
+
+/* AS: Added to keep the match node map etc after a match
+   When this information is not needed any more, ext_grs_free_match has to be called. */
+
+void ext_grs_free_match(ext_grs_match_t *match)
+{
+       /* clear the match object */
+       /* first: free the match objects obstack */
+       obstack_free(&(match->obst), NULL);
+       /* second: free the match object itself */
+       free(match);
+}
+
+
+
+int ext_grs_get_n_matches(ext_grs_match_t *match) {
+       if (! match) {
+               printf("module ext/grs: ERROR in function ext_grs_get_n_matches()\n");
+               printf("  the match id given was to large\n");
+               assert(0);
+               return 0;
+       }
+
+       return match->n_matches;
+}
+
+
+ir_graph *ext_grs_get_match_irg(ext_grs_match_t *match) {
+       if (! match) {
+               printf("module ext/grs: ERROR in function ext_grs_get_match_irg()\n");
+               printf("  the match id given was to large\n");
+               assert(0);
+               return NULL;
+       }
+
+       return match->irg;
+}
+
+
+ir_node **ext_grs_get_match_node_map(ext_grs_match_t *match, int which) {
+
+       if (which >= match->n_matches) {
+               printf("module ext/grs: ERROR in function ext_grs_get_match_node_map()\n");
+               printf("  the match id given was to large\n");
+               assert(0);
+               return NULL;
+       }
+
+       return match->nodes[which];
+}
+
+ir_node **ext_grs_get_replace_node_map(ext_grs_match_t *match, int which) {
+
+       if (which >= match->n_matches) {
+               printf("module ext/grs: ERROR in function ext_grs_get_match_node_map()\n");
+               printf("  the match id given was to large\n");
+               assert(0);
+               return NULL;
+       }
+
+       return match->repl_nodes[which];
+}
+
+
+
+const ir_edge_t **ext_grs_get_match_edge_map(ext_grs_match_t *match, int which) {
+
+       if (which >= match->n_matches) {
+               printf("module ext/grs: ERROR in function ext_grs_get_match_node_map()\n");
+               printf("  the match id given was to large\n");
+               assert(0);
+               return NULL;
+       }
+
+       return match->edges[which];
+}
+
+
+int ext_grs_get_match_max_node_aiid(ext_grs_match_t *match)
+{
+       return(match->max_node_id);
+}
+
+int ext_grs_get_match_max_edge_aiid(ext_grs_match_t *match)
+{
+       return(match->max_edge_id);
+}

diff --git a/ir/be/grgen/match.h b/ir/be/grgen/match.h
new file mode 100644 (file)
index 0000000..7e24402
--- /dev/null
+++ b/ir/be/grgen/match.h
@@ -0,0 +1,142 @@
+#ifndef _EXT_GRS_MATCH_H_
+#define _EXT_GRS_MATCH_H_
+
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/match.h
+ * Purpose:     provides an interface for subgraph matching
+ * Author:      Veit Batz
+ * Modified by: Andreas Schoesser
+ * Created:            6. August 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+/** Do the matching \b compliant, i.e. the matching allows
+ *  parallel independent rule application. */
+#define ext_grs_COMPLIANT 1
+/** Do the matching \b not compliant, i.e. the
+ *  matching does \b not regard parallel independent rule application. */
+#define ext_grs_REGARDLESS 0
+/** Find \b all occurences of the pattern graph in a given host graph,
+ *  or in case of compliant matching, as much as possible occurences,
+ *  which can be replaced parallel independent.
+ *  @note It is \b not guarantied that the maximal possible number
+ *             of matches is found. */
+#define ext_grs_ALL -1
+
+
+#include "matchplan.h"
+
+
+
+/** graph matching result */
+typedef struct _ext_grs_match_t ext_grs_match_t;
+
+/** wraps initial bindings for pivoted graph matching */
+typedef struct _ext_grs_binding_t ext_grs_binding_t;
+
+
+
+
+
+
+
+/** find at most n matches
+ *
+ *  @param irg                 the host graph to be matched in
+ *  @param plan                        the matching plan parametrizing the search
+ *  @param n                   the maximum number of matches (-1 means all, if compliant
+ *                                             matching is activated not all, but as many as feasible
+ *                                             \b compliant matches are found)
+ *  @param compliant   match compliant if nonzero, i.e. find only matches
+ *                                             that can be rewritten concurrently
+ */
+ext_grs_match_t *ext_grs_match(
+       ir_graph *irg, ext_grs_match_plan_t *plan, int n, int compliant);
+
+/** find at most n matches
+ *
+ *  @param irg                 the host graph to be matched in
+ *  @param plan                        the matching plan parametrizing the search
+ *  @param n                   the maximum number of matches (-1 means all, if compliant
+ *                                             matching is activated not all, but as many as feasible
+ *                                             \b compliant matches are found)
+ *  @param compliant   match compliant if non zero, i.e. find only matches
+ *                                             that can be rewritten concurrently
+ *  @param binding             initial binding of pattern nodes/edges to host graph
+ *                                             nodes/edges, in the binding struct the appropriate
+ *                                             pattern and host graph nodes/edges have the same index
+ *
+ * @returns    a matching result
+ */
+ext_grs_match_t *ext_grs_match_pivot(ir_graph *irg,
+       ext_grs_match_plan_t *plan, int n, int compliant, ext_grs_binding_t *binding);
+
+/** perform rewriting step
+ *
+ *  @param match       a matching result
+ *  @param n           The number of matches to be replaced, if n=0 no
+ *                                     replacement is performed, if n=-1 \b all matches
+ *                                     will be replaced. If n=-1 or n>1 the matching result
+ *                                     has to be compliant.
+ *  @param which       An array containing the indices of the n matches to
+ *                                     be replaced. If \b all matches shall be replaced this
+ *                                     parameter will be ignored.
+ *  @note The match object is freed afterwards. */
+void ext_grs_finish_match(ext_grs_match_t *match, int n, int *which);
+void ext_grs_free_match(ext_grs_match_t *match);
+
+/** get the number of matches in the given matching result
+ *  @param match       a matching result
+ *  @returns the number of matches
+ */
+int ext_grs_get_n_matches(ext_grs_match_t *match);
+
+/** get the ir graph of a given matching result
+ *  @param match       a matching result
+ *  @returns the ir graph the matching result belongs to
+ */
+ir_graph *ext_grs_get_match_irg(ext_grs_match_t *match);
+
+/** get the node map of a match in a given matching result
+ *
+ *  @param     match   a matching result
+ *  @param which       the number of the match in the matching result
+ *
+ *  @returns the node map of the match
+ */
+ir_node **ext_grs_get_match_node_map(ext_grs_match_t *match, int which);
+
+/** get the node map of a match in a given matching result
+ *
+ *  @param     match   a matching result
+ *  @param which       the id of the match in the matching result
+ *
+ *  @returns the edge map of the match
+ */
+const ir_edge_t **ext_grs_get_match_edge_map(ext_grs_match_t *match, int which);
+
+ir_node **ext_grs_get_replace_node_map(ext_grs_match_t *match, int which);
+
+/** dump the given ir graph the matching result belongs to where all matches
+ *  of the given matching result are represented by a virtual "Match" node and
+ *  some edges pointing from the Match node to the regarding nodes. All nodes
+ *  and edges which belong to am match are drawed in red color.
+
+ *  @param match       a matching result
+ *  @param
+ *
+ *  @returns the number of matches
+ */
+void ext_grs_dump_match(ext_grs_match_t *match, const char *suffix);
+
+int ext_grs_get_match_max_node_aiid(ext_grs_match_t *match);
+
+int ext_grs_get_match_max_edge_aiid(ext_grs_match_t *match);
+
+
+
+#endif /*_EXT_GRS_MATCH_H_*/

diff --git a/ir/be/grgen/match_t.h b/ir/be/grgen/match_t.h
new file mode 100644 (file)
index 0000000..a73587f
--- /dev/null
+++ b/ir/be/grgen/match_t.h
@@ -0,0 +1,75 @@
+#ifndef _EXT_GRS_MATCH_T_H_
+#define _EXT_GRS_MATCH_T_H_
+
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/match_t.h
+ * Purpose:     provides the libfirm internal version of the interface
+ *              for subgraph matching
+ * Author:      Veit Batz
+ * Created:            7. Junly 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+#include "common_t.h"
+#include "matchplan_t.h"
+
+#include "match.h"
+
+
+/** graph matching result */
+struct _ext_grs_match_t {
+       /** the action this match belongs to */
+       ext_grs_action_t *action;
+       /** the host graph matched in */
+       ir_graph *irg;
+       /** flag: match valid */
+       int compliant;
+       /** the number of matches found */
+       int n_matches;
+       /** the number of nodes in each match */
+       int n_nodes;
+       /** the number of edges in each match */
+       int n_edges;
+       /** maximum node id in this match */
+       int max_node_id;
+       /** maximum edge id in this match */
+       int max_edge_id;
+       /** array of arrays, each mapping node/edge ids to (ir_node*),
+        *  the length is max_node_id + 1 */
+       ir_node ***nodes;
+       /** array of arrays, each mapping edge ids to (ir_node*),
+        *  the length is max_edge_id + 1 */
+       const ir_edge_t ***edges;
+       /** array of arrays, each mapping replace_node/edge ids to (ir_node*) */
+       ir_node ***repl_nodes;
+       /** internal obstack of the match object */
+       struct obstack obst;
+};
+
+/** wraps initial bindings for pivoted graph matching */
+struct _ext_grs_binding_t {
+       /** number of bound host graph fragments */
+       int size;
+       /** number of involved pattern nodes */
+       int n_nodes;
+       /** number of involved pattern edges */
+       int n_edges;
+       /** the bound pattern nodes */
+       ext_grs_node_t *pat_nodes;
+       /** the bound pattern edges */
+       ext_grs_edge_t *pat_edges;
+       /** the ir nodes bound to the pattern nodes given by their index (node map) */
+       ir_node ***nodes;
+       /** the ir edges bound to the pattern edges given by their index (edge map) */
+       ir_edge_t ***edges;
+};
+
+
+void _ext_grs_match_init(void);
+
+
+
+#endif /*_EXT_GRS_MATCH_T_H_*/

diff --git a/ir/be/grgen/matchplan.c b/ir/be/grgen/matchplan.c
new file mode 100644 (file)
index 0000000..ac47ffe
--- /dev/null
+++ b/ir/be/grgen/matchplan.c
@@ -0,0 +1,72 @@
+
+/*
+ * Project:     libFIRM/extension module/GRS-matcher
+ * File name:   ext/grs/plan.h
+ * Purpose:     provides an interface for search planers planing
+ *                             the matching process with respect to information
+ *                             provided by appropriate analyzers
+ * Author:      Veit Batz
+ * Modified by: Andreas Schoesser
+ * Created:            16. August 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+
+#include "matchplan_t.h"
+
+
+/**dump a search plans to stdout */
+void ext_grs_dump_match_plan(ext_grs_match_plan_t *plan) {
+       int i, j;
+
+       printf("\nA plan for action %s: \n", plan->action->name);
+
+       for(j = 0; j < plan->num_progs; j++)
+       {
+               if(j == 0)
+                       printf("Positive plan:\n");
+               else
+                       printf("NAC plan %d:\n", j - 1);
+
+               for (i = 0; i < plan->length[j]; i++) {
+                       ext_grs_match_op_t *mop;
+                       mop = & plan->progs[j][i];
+                       switch(mop->kind)
+                       {
+                       case ext_grs_k_mop_node:
+                               printf("  node(%s)\n", mop->node->name);
+                               break;
+                       case ext_grs_k_mop_edge:
+                               printf("  edge(%s, %s)\n", mop->node->name, mop->edge->name);
+                               break;
+                       case ext_grs_k_mop_condition:
+                               printf("  condition\n");
+                               break;
+                       case ext_grs_k_mop_preset:
+                               printf("  preset_node(%s)\n", mop->node->name);
+                               break;
+                       case ext_grs_k_mop_preset_edge:
+                               printf("  preset_edge(%s, %s)\n", mop->node->name, mop->edge->name);
+                               break;
+                       default:
+                               printf("  invalid matcher op\n");
+                               break;
+                       }
+               }
+       }
+}
+
+/** initialize a planer */
+void ext_grs_init_planer(ext_grs_planer_t *planer, ext_grs_analyzer_t *alz) {
+       planer->init(planer, alz);
+}
+
+/** compute a match plan */
+ext_grs_match_plan_t *ext_grs_compute_plan(
+       ext_grs_planer_t *planer, ir_graph *irg, ext_grs_action_t *act)
+{
+       return planer->compute_plan(planer, irg, act);
+}

diff --git a/ir/be/grgen/matchplan.h b/ir/be/grgen/matchplan.h
new file mode 100644 (file)
index 0000000..1f70ad9
--- /dev/null
+++ b/ir/be/grgen/matchplan.h
@@ -0,0 +1,69 @@
+#ifndef _EXT_GRS_MATCHPLAN_H_
+#define _EXT_GRS_MATCHPLAN_H_
+
+/*
+ * Project:     libFIRM/extension module/GRS-matcher
+ * File name:   ext/grs/plan.h
+ * Purpose:     provides an interface for search planers planing
+ *                             the matching process with respect to information
+ *                             provided by appropriate analyzers
+ * Author:      Veit Batz
+ * Modified by: Andreas Schoesser
+ * Created:            6. August 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+
+#include "action.h"
+#include "analyze.h"
+
+
+
+/** a plan the matching process will follow */
+typedef struct _ext_grs_match_plan_t ext_grs_match_plan_t;
+
+/** a planer for the creation of matching plans */
+typedef struct _ext_grs_planer_t ext_grs_planer_t;
+
+typedef struct {
+       int n_nodes;
+       ext_grs_node_t **pat_nodes;
+       ir_node **host_nodes;
+       int n_edges;
+       ext_grs_edge_t **pat_edges;
+       ir_edge_t **host_edges;
+} ext_grs_graph_fragment_t;
+
+
+
+
+
+
+/** initialize a planer */
+void ext_grs_init_planer(ext_grs_planer_t *planer, ext_grs_analyzer_t *alz);
+
+/** compute a match plan */
+ext_grs_match_plan_t *ext_grs_compute_plan(
+       ext_grs_planer_t *planer, ir_graph *irg, ext_grs_action_t *act);
+
+/** compute a match plan according to analysis data of all ir graphs */
+ext_grs_match_plan_t *ext_grs_compute_plan_global(
+       ext_grs_planer_t *planer, ext_grs_action_t *act);
+
+/**dump a search plans to stdout */
+void ext_grs_dump_match_plan(ext_grs_match_plan_t *);
+
+
+
+ext_grs_match_plan_t *ext_grs_compute_plan_pivot(ext_grs_planer_t *planer,
+       ir_graph *irg, ext_grs_action_t *act, ext_grs_graph_fragment_t *bound);
+ext_grs_match_plan_t *ext_grs_compute_plan_global_pivot(ext_grs_planer_t *planer,
+       ext_grs_action_t *act, ext_grs_graph_fragment_t *bound);
+
+
+
+
+
+#endif /*_EXT_GRS_MATCHPLAN_H_*/

diff --git a/ir/be/grgen/matchplan_t.h b/ir/be/grgen/matchplan_t.h
new file mode 100644 (file)
index 0000000..5df8449
--- /dev/null
+++ b/ir/be/grgen/matchplan_t.h
@@ -0,0 +1,84 @@
+#ifndef _EXT_GRS_MATCHPLAN_T_H_
+#define _EXT_GRS_MATCHPLAN_T_H_
+
+/*
+ * Project:     libFIRM/extension module/GRS-matcher
+ * File name:   ext/grs/plan_t.h
+ * Purpose:     provides an interface for search planers planing
+ *                             the matching process with respect to information
+ *                             provided by appropriate analyzers
+ * Author:      Veit Batz
+ * Created:            7. July 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+#include "action_t.h"
+#include "analyze_t.h"
+#include "matchplan.h"
+
+typedef enum {
+       ext_grs_k_mop_node,
+       ext_grs_k_mop_edge,
+       ext_grs_k_mop_condition,
+       ext_grs_k_mop_preset,
+       ext_grs_k_mop_preset_edge
+} ext_grs_mop_kind_t;
+
+typedef struct {
+       /** tells wether this op matches a node or an edge */
+       ext_grs_mop_kind_t kind;
+       /** if this match op matches an edge, then this is the respective pattern edge */
+       ext_grs_edge_t *edge;
+       /** if this match op matches a node, then this is the respective pattern node,
+        * if this op matches an edge, then this node is the pattern node where the
+        * edge is retrieved from */
+       ext_grs_node_t *node;
+       /** a condition to be checked by this matching op */
+       ext_grs_condition_func_t condition;
+       /** an op condition to be checked by this matching op (for node-ops only) */
+       ext_grs_op_condition_func_t op_condition;
+       /** a mode condition to be checked by this matching op (for node-ops only) */
+       ext_grs_mode_condition_func_t mode_condition;
+} ext_grs_match_op_t;
+
+/** a plan the matching process will follow */
+struct _ext_grs_match_plan_t {
+       /** the action this matching plan belongs to */
+       ext_grs_action_t *action;
+       /** the number of matching ops of this search plan */
+       /*int length;*/
+       int num_progs;
+       int *length;
+       /** a sequence (array) of match ops (i.e. the matching 'program') */
+       /* Contains pointers to all search plans (positive and negative) */
+       ext_grs_match_op_t **progs;
+       /* Just for "backward compatibility:
+          Contains pointer to the positive search plan */
+       ext_grs_match_op_t *prog;
+};
+
+/** a planer fir the creation of matching plans */
+struct _ext_grs_planer_t {
+       /** a tag identifying a planer */
+       const char *tag;
+       /** this planers analyzer  */
+       ext_grs_analyzer_t *analyzer;
+
+       /** initialize this planer */
+       void (*init) (struct _ext_grs_planer_t *, ext_grs_analyzer_t *);
+       /** compute a match plan according to analysis data of a given  ir graph */
+       ext_grs_match_plan_t * (*compute_plan)
+               (struct _ext_grs_planer_t *, ir_graph *, ext_grs_action_t *);
+       /** compute a match plan according to analysis data of all ir graphs */
+       ext_grs_match_plan_t * (*ext_grs_compute_plan_global)
+               (struct _ext_grs_planer_t *, ext_grs_action_t *);
+
+       /** this planers private data area */
+       void *data;
+};
+
+
+
+#endif /*_EXT_GRS_MATCHPLAN_T_H_*/

diff --git a/ir/be/grgen/plan_vs_dmst.c b/ir/be/grgen/plan_vs_dmst.c
new file mode 100644 (file)
index 0000000..0201459
--- /dev/null
+++ b/ir/be/grgen/plan_vs_dmst.c
@@ -0,0 +1,1620 @@
+/*
+ * Project:     libFIRM/extension module/graph rewriting system
+ * File name:   ext/grs/plan_vs.c
+ * Purpose:     provides a planar wich performs a bypassing of
+ *                             v-structures by real valued costs
+ * Author:      Veit Batz
+ * Created:            11. Junly 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+
+#include "common_t.h"
+
+#include "auxilary_t.h"
+#include "base_t.h"
+#include "action_t.h"
+#include "analyze_t.h"
+#include "ana_vs_t.h"
+#include "matchplan_t.h"
+
+#include "uf_mpq.h"
+
+#include "plan_vs_dmst.h"
+#include "action_t.h"
+
+
+
+
+typedef struct _ext_grs_vs_dmst_planer_private_t {
+       /* tells wether an edge has been chosen */
+       int *chosen;
+       /* tells wether a node has been already reached by the MDST */
+       int *mdst_reached;
+       /* An array of edge ptrs. Each ptr
+        * denotes the edge visited during the MDST computation before the edge,
+        * with a given aiid, i.e. the path successor of this edge in forward direction.
+        * If the edge belongs to a circle found during the MDST computation, this ptr
+        * points to the next circle edge. If the edges tgt node is a super node,
+        * the ptr points to the next edge on the same level, i.e. if the edge belongs
+        * not to a super node itself, the ptr points to the path successor in
+        * forward direction, if the edge belongs to a super node itself, the
+        * ptr points to the next circle edge. */
+       ext_grs_edge_t **edge_path_succ;
+       /* An array of edge ptrs.
+        * If an edge with a given aiid is an outgoing edge of a super node build
+        * during the MDST computation the respective ptr points to the last edge
+        * of the circle on forward direction */
+       ext_grs_edge_t **super_node_last_edge;
+       /* needed in the actual plan generation, to remember which condition
+        * functions have already been placed in a matching op */
+       lc_bitset_t *already_placed_conditions;
+       /* needed in the actual plan generation, to remember which nodes have
+        * alredy been matvhed by a generated mop */
+       lc_bitset_t *already_matched_nodes;
+       /* needed in the actual plan generation, to remember which edges have
+        * alredy been matvhed by a generated mop */
+       lc_bitset_t *already_matched_edges;
+       /* tells wether a node with a given node id has been visited yet,
+        * if not the value in the array is '0', if yes the value is the
+        * number of the  */
+       int *visited;
+       /* an array of edge ptr, each pointing to a root of an edge path builded
+        * during the MDST computation */
+       ext_grs_edge_t **edge_path_roots;
+       /* number of edge path roots stored in that array */
+       int n_edge_path_roots;
+
+} ext_grs_vs_dmst_planer_private_t;
+
+
+
+#define UF_FIND(e) (ext_grs_uf_find((e)+1) - 1)
+#define UF_FIND_VALUE(e) (ext_grs_uf_find_value((e)+1))
+#define UF_UNITE(r1,r2)  (ext_grs_uf_unite((r1)+1,(r2)+1) - 1)
+#define UF_CHANGE_VALUE(r,a) (ext_grs_uf_change_value((r)+1,(a)))
+
+
+/* auxilary function for debugging purposes */
+static void dump_edge_path(ext_grs_vs_dmst_planer_private_t *p, ext_grs_edge_t *edge) {
+
+       ext_grs_edge_t *current_edge = edge;
+       assert(edge);
+
+       printf("An edge path:\n");
+       do
+       {
+               printf("  edge %s\n", current_edge->name);
+               current_edge = p->edge_path_succ[current_edge->aiid];
+       }
+       while (current_edge != NULL && current_edge != edge);
+       printf("\n\n");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* auxiliary function needed in the expansion step of the MDST algorithm,
+ * checks whether there is a reached node in a super node */
+static int examine_super_node(
+       ext_grs_vs_dmst_planer_private_t *p,
+       ext_grs_edge_t *start_edge)
+{
+       ext_grs_edge_t *current_edge = NULL;
+       int already_reached_node_found = 0;
+
+       /* walk the circle forming the current super node */
+       assert(start_edge && "NULL edge given");
+       current_edge = start_edge;
+       do {
+
+               /* if the current edges real target node is already reached by an MDST edge,
+               * report, that a reached node is found in the current super node */
+               if ( p->mdst_reached[current_edge->arg->aiid] ) return 1;
+
+               /* if the current edges target node is a super node,
+                * recursively examine that super node too */
+               if (p->super_node_last_edge[current_edge->aiid]) {
+                       already_reached_node_found =
+                               examine_super_node(p,
+                                       p->edge_path_succ[
+                                               p->super_node_last_edge[current_edge->aiid]->aiid
+                                       ]
+                               );
+               }
+               if (already_reached_node_found) return 1;
+
+               /* process the next edge of the circle */
+               current_edge = p->edge_path_succ[current_edge->aiid];
+               assert(current_edge && "in a circle the edge path should form a circle too");
+       }
+       while (current_edge != start_edge);
+
+       /* report that no reached node has been found in the current super node */
+       return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+/* auxiliary function needed in the expansion step of the MDST algorithm,
+ * walks a super node and kills one specific edge */
+static void expand_super_node(
+       ext_grs_vs_dmst_planer_private_t *p,
+       ext_grs_edge_t *start_edge)
+{
+       ext_grs_edge_t *current_edge;
+
+       assert(start_edge);
+
+       /* Walk the circle and choose every edge marking its target node as reached, except...
+        * ...the edge already has an already reached real target node OR
+        * ...the edges target node is a super node containing an already reached real node.
+        * If an edge has a super node as target node recursively expand that super node too. */
+       current_edge = start_edge;
+       do {
+
+               /* tells whether the current edges target node is a super node
+                * containing an already reached real node */
+               int super_node_contains_reached_node = 0;
+               /* represents the start edge of a super node circle */
+               ext_grs_edge_t *super_node_start_edge = NULL;
+               /* represents the last edge of a super node circle */
+               ext_grs_edge_t *super_node_end_edge = NULL;
+
+
+               super_node_end_edge = p->super_node_last_edge[current_edge->aiid];
+               if (super_node_end_edge)
+                       super_node_start_edge = p->edge_path_succ[ super_node_end_edge->aiid ];
+
+               /* if the current edges target is a super node, check whether
+                * this super node contains an already reached real node */
+               super_node_contains_reached_node = 0;
+               if (super_node_start_edge) {
+                       super_node_contains_reached_node = examine_super_node(p, super_node_start_edge);
+               }
+
+               /* mark the current edge as chosen and its real target node as reached, except... (see above) */
+               if (
+                       ! p->mdst_reached[current_edge->arg->aiid] &&
+                       ! super_node_contains_reached_node
+               )
+               {
+                       p->chosen[current_edge->aiid] = 1;
+                       p->mdst_reached[current_edge->arg->aiid] = 1;
+               }
+
+               /* if the current edges target node is a super node, then recursively expand it */
+               if (super_node_start_edge) {
+                       expand_super_node(p, super_node_start_edge);
+               }
+
+               /* process the next edge of the super node circle */
+               current_edge = p->edge_path_succ[current_edge->aiid];
+               assert(current_edge);
+       }
+       while (current_edge != start_edge);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#if 0
+
+
+
+/* auxiliary function needed in the expansion step of the MDST algorithm,
+ * walks a super node where the edge to be killed is initially not known */
+static void expand_super_node_examine(
+       ext_grs_vs_dmst_planer_private_t *p,
+       ext_grs_edge_t *start_edge)
+{
+
+       ext_grs_edge_t *current_edge = NULL;
+       int edge_killed = 0;
+
+       #ifdef EXT_GRS_DEBUG
+               printf("Expanding a super node (examine). Start edge is %s\n", start_edge->name);
+               printf("The circle of edges forming the super node: ");
+       #endif
+
+
+       /* walk the circle forming the current super node */
+       assert(start_edge && "NULL edge given");
+       edge_killed = 0;
+
+       current_edge = start_edge;
+       #ifdef EXT_GRS_DEBUG
+               printf("%s ", current_edge->name);
+       #endif
+       do {
+
+               /* if the current edges target node is a super node, expand that super node */
+               if (p->super_node_last_edge[current_edge->aiid] != NULL) {
+
+                       #ifdef EXT_GRS_DEBUG
+                               printf(" Recursively stepping into super node:\n{\n");
+                       #endif
+
+                       expand_super_node_examine(p,
+                               p->edge_path_succ[
+                                       p->super_node_last_edge[current_edge->aiid]->aiid
+                               ]
+                       );
+
+                       #ifdef EXT_GRS_DEBUG
+                               printf("}\n");
+                       #endif
+               }
+               /* if the current edges real target node is already reached by an MDST edge,
+                * do NOT choose the current edge for the MDST but remember that there's already
+                * an edge in the current circle, which has not been chosen for the MDST */
+               if ( p->mdst_reached[current_edge->arg->aiid] ) {
+                       /* all but exactly one edge of a circle have to be chosen for the MDST */
+                       assert( !edge_killed && "more than one circle edge not chosen for the MDST");
+                       /* remember that theres already is an edge not chosen */
+                       edge_killed = 1;
+               }
+               else {
+                       /* otherwise the current edge is chosen, except
+                        * ... OR
+                        * ...it is the last edge of the current circle and no edge edge has been not killed yet */
+                       if ( p->edge_path_succ[current_edge->aiid] != start_edge || edge_killed )
+                       {
+                               p->chosen[current_edge->aiid] = 1;
+                               p->mdst_reached[current_edge->arg->aiid] = 1;
+                       }
+
+               }
+               /* process the next edge of the circle */
+               current_edge = p->edge_path_succ[current_edge->aiid];
+               assert(current_edge && "in a circle the edge path should form a circle too");
+               #ifdef EXT_GRS_DEBUG
+                       printf("%s ", current_edge->name);
+               #endif
+       }
+       while (current_edge != start_edge);
+
+       #ifdef EXT_GRS_DEBUG
+               printf("\n");
+       #endif
+}
+
+
+
+
+
+/* auxilary function needed in the expansion step of the MDST algorithm,
+ * walks a super node where the given edge is the edge to be killed from
+ * the MDST and the other edges are to be chosen for the MDST */
+static void expand_super_node_killing(
+       ext_grs_vs_dmst_planer_private_t *p,
+       ext_grs_edge_t *kill_edge)
+{
+       ext_grs_edge_t *current_edge;
+
+       #ifdef EXT_GRS_DEBUG
+               printf("\nExpanding a super node (kill). ");
+       #endif
+
+       assert(kill_edge);
+
+       #ifdef EXT_GRS_DEBUG
+               printf("Kill-edge is %s\n", kill_edge->name);
+               printf("The circle of edges forming the super node: ");
+       #endif
+
+       /* walk the circle for the first time:
+        * every edge except the edge to be killed is marked as chosen, the real
+        * target node of such an edge is to be marked es reached by the MDST */
+       current_edge = p->edge_path_succ[kill_edge->aiid];
+       assert(current_edge);
+       #ifdef EXT_GRS_DEBUG
+               printf("%s ", current_edge->name);
+       #endif
+       assert(current_edge != kill_edge); /* no loops allowed! */
+
+       do {
+               p->mdst_reached[current_edge->arg->aiid] = 1;
+               p->chosen[current_edge->aiid] = 1;
+               current_edge = p->edge_path_succ[current_edge->aiid];
+               assert(current_edge);
+               #ifdef EXT_GRS_DEBUG
+                       printf("%s ", current_edge->name);
+               #endif
+       }
+       while (current_edge != kill_edge);
+
+       #ifdef EXT_GRS_DEBUG
+               printf("\n");
+       #endif
+
+       /* walk the circle for the second time...
+        * while every super node is expanded. Note that there is a different
+        * treatment of supernodes pointed to by the edge to be killed and by
+        * the other edges: two different functions are called */
+       current_edge = p->edge_path_succ[kill_edge->aiid];
+       assert(current_edge);
+       assert(current_edge != kill_edge); /* no loops allowed! */
+
+       do {
+               if (p->super_node_last_edge[current_edge->aiid])
+                       expand_super_node_killing(p, p->super_node_last_edge[current_edge->aiid]);
+               current_edge = p->edge_path_succ[current_edge->aiid];
+       }
+       while (current_edge != kill_edge);
+       /* now the super node pointed to by the edge to be killed is expanded
+        * (if there is one) */
+       if (p->super_node_last_edge[kill_edge->aiid])
+               expand_super_node_examine(p,
+                       p->edge_path_succ[
+                               p->super_node_last_edge[kill_edge->aiid]->aiid
+                       ]
+               );
+}
+
+#endif
+
+
+
+/* Place all conditions in the mop, which can now be computed
+* and have not been computed yet. If there are more than one
+* such conditions generate additional condition mops. */
+static INLINE void emit_nodes_conditions(
+       ext_grs_action_t *act, ext_grs_node_t *node,
+       ext_grs_vs_dmst_planer_private_t *p,  ext_grs_match_op_t *prog, int *prog_pos)
+{
+       /* flag, tells whether there has already been placed a condition
+       * in the current edges mop (so additional condition mops have
+       * to be created) */
+       int already_placed = 0;
+
+       /* a condition index from a set of involved conditions */
+       lc_bitset_pos_t cond = (act->nodes_refering_conds[node->aiid])->size;
+
+       /* a matcher op */
+       ext_grs_match_op_t *mop;
+
+       if (act->n_conditions > 0) {
+               lc_bitset_foreach(act->nodes_refering_conds[node->aiid], cond) {
+
+                       /* if current condition has already been placed in the plan
+                       * currently generated, then skip */
+                       if (lc_bitset_is_set(p->already_placed_conditions, cond)) continue;
+
+                       /* otherwise check, whether all involved nodes
+                       * and edges have already been matched  */
+                       if (
+                               ! lc_bitset_contains(
+                               act->conds_involved_nodes[(int)cond],
+                               p->already_matched_nodes)
+                               ) continue;
+
+                       /* otherwise place the condition in the mop or (if there has already
+                       * been placed one) create a condition mop. */
+                       if (already_placed) {
+                               int j = ++(*prog_pos);   // Create a condition mop;
+                               mop = & prog[j];
+                               mop->kind = ext_grs_k_mop_condition;
+                               mop->condition = act->conditions[(int)cond];
+                               lc_bitset_set(p->already_placed_conditions, cond);                              // AS
+                       }
+                       else {
+                               mop = &prog[*prog_pos]; // AS
+                               mop->condition = act->conditions[(int)cond];
+                               already_placed = 1;
+                               lc_bitset_set(p->already_placed_conditions, cond);  // AS
+                       }
+               }
+       }
+}
+
+
+
+/* Place all conditions in the mop, which can now be computed
+ * and have not been computed yet. If there are more than one
+ * such conditions generate additional condition mops. */
+static INLINE void emit_edges_conditions(
+       ext_grs_action_t *act, ext_grs_edge_t *edge,
+       ext_grs_vs_dmst_planer_private_t *p, ext_grs_match_op_t *prog, int *prog_pos)
+{
+       /* flag, tells whether there has already been placed a condition
+        * in the current edges mop (so additional condition mops have
+        * to be created) */
+       int already_placed = 0;
+
+       /* a condition index from a set of involved conditions */
+       lc_bitset_pos_t cond;
+
+       /* a matcher op */
+       ext_grs_match_op_t *mop;
+
+       if (act->n_conditions > 0) {
+
+               // Place conditions for source and target of the edge, if they have not been
+               // placed yet while emitting the "node operation".
+               if(edge->func != NULL)                                                                                          // AS
+                       emit_nodes_conditions(act, edge->func, p, prog, prog_pos);              // AS
+               if(edge->arg != NULL)                                                                                           // AS
+                       emit_nodes_conditions(act, edge->arg, p, prog, prog_pos);               // AS
+
+               lc_bitset_foreach(act->edges_refering_conds[edge->aiid], cond) {
+                       /* if current condition has already been placed in the plan
+                        * currently generated, then skip */
+                       if (lc_bitset_is_set(p->already_placed_conditions, cond)) continue;
+                       /* otherwise check, whether all involved nodes
+                        * and edges have already been matched  */
+                       if (
+                               ! lc_bitset_contains(
+                                       act->conds_involved_nodes[(int)cond],
+                                       p->already_matched_nodes)
+                       ) continue;
+                       /* otherwise check, whether all involved edges
+                        * and edges have already been matched  */
+                       if (
+                               ! lc_bitset_contains(
+                                       act->conds_involved_edges[(int)cond],
+                                       p->already_matched_edges)
+                       ) continue;
+                       /* otherwise place the condition in the mop or (if there has already
+                        * been placed one) create a condition mop. */
+                       if (already_placed) {
+                               int j = ++(*prog_pos);
+                               mop = & prog[j];
+                               mop->kind = ext_grs_k_mop_condition;
+                               mop->condition = act->conditions[(int)cond];
+                               lc_bitset_set(p->already_placed_conditions, cond); // AS
+                       }
+                       else {
+                               mop = &prog[*prog_pos];  // AS
+                               mop->condition = act->conditions[(int)cond];
+                               already_placed = 1;
+                               lc_bitset_set(p->already_placed_conditions, cond); // AS
+                       }
+               }
+       }
+}
+
+
+
+static void emit_mop(
+       ext_grs_vs_dmst_planer_private_t *p,
+       ext_grs_action_t *act, ext_grs_match_op_t *prog,
+       ext_grs_edge_t *edge,  int *prog_pos)
+{
+
+       /* a matcher op */
+       ext_grs_match_op_t *mop;
+       int j = *prog_pos;
+
+       mop = &prog[j];
+
+       /* write the respective node or edge into the mop */
+       if (edge->kind == ext_grs_k_edge) {
+               ext_grs_edge_t *back_edge;
+
+               mop->kind = ext_grs_k_mop_edge;
+               mop->edge = edge;
+               mop->node = edge->func;
+
+               mop->edge->first_mop_index = j;
+
+               /* mark the pseudo edge representing the backward
+                * traversal of the edge also as chosen such that
+                * it can not be used for the generation of matcher
+                * ops anymore, or if already chosen, remove it
+                * from the priority queue of allowed edges */
+               back_edge = edge->backward_edge;
+               if (p->chosen[back_edge->aiid] == 2) {
+                       ext_grs_mpq_delete(back_edge);
+               }
+               else {
+                       p->chosen[edge->backward_edge->aiid] = 2;
+               }
+
+               /* mark the genuine node as already been matched */
+               lc_bitset_set(p->already_matched_edges, edge->aiid);
+               /* mark the genuine node as already been matched */
+               lc_bitset_set(p->already_matched_nodes, edge->arg->aiid);
+
+               emit_edges_conditions(act, edge, p, prog, prog_pos);
+       }
+       else {
+               ext_grs_elem_t *genuine_elem;
+
+               assert(edge->kind == ext_grs_k_pseudo_edge && "invalid kind");
+               /* get the genuine elem */
+               genuine_elem = & edge->genuine_elem;
+               if (genuine_elem->kind == ext_grs_k_edge) {
+                       /* pseudo edge represents a reverse edge matching */
+                       ext_grs_edge_t *genuine_edge = genuine_elem->val.e;
+
+                       if(genuine_edge->related_edge != NULL)
+                               mop->kind = ext_grs_k_mop_preset_edge;
+                       else
+                               mop->kind = ext_grs_k_mop_edge;
+                       mop->edge = genuine_edge;
+                       mop->node = genuine_edge->arg;
+
+                       mop->edge->first_mop_index = j;
+
+                       /* mark the actual edge belonging to the
+                        * pseudo edge representing the backward
+                        * traversal of the that actual edge also as chosen
+                        * such that it can not be used for the generation
+                        * of matcher ops anymore, or if already chosen,
+                        * remove it from the priority queue of allowed edges */
+                       if (p->chosen[genuine_edge->aiid] == 2) {
+                               ext_grs_mpq_delete(genuine_edge);
+                       }
+                       else {
+                               p->chosen[genuine_edge->aiid] = 2;
+                       }
+
+                       /* mark the genuine node as already been matched */
+                       lc_bitset_set(p->already_matched_edges, genuine_edge->aiid);
+                       /* mark the genuine node as already been matched */
+                       lc_bitset_set(p->already_matched_nodes, genuine_edge->func->aiid);
+
+                       emit_edges_conditions(act, genuine_edge, p, prog, prog_pos);
+
+               }
+               else {
+                       /* pseudo edge represents a node matching */
+                       ext_grs_node_t *genuine_node = genuine_elem->val.n;
+
+                       assert(genuine_elem->kind == ext_grs_k_node && "invalid kind");
+                       assert(genuine_node == edge->arg);
+
+                       if(genuine_node->related_node != NULL)
+                               mop->kind = ext_grs_k_mop_preset;
+                       else
+                               mop->kind = ext_grs_k_mop_node;
+                       mop->edge = NULL;
+                       mop->node = genuine_node;
+
+                       if (genuine_node->op_condition)
+                               mop->op_condition = genuine_node->op_condition;
+                       if (genuine_node->mode_condition)
+                               mop->mode_condition = genuine_node->mode_condition;
+
+                       /* mark the genuine node as already been matched */
+                       lc_bitset_set(p->already_matched_nodes, genuine_node->aiid);
+
+                       emit_nodes_conditions(act, genuine_node, p, prog, prog_pos);
+               }
+       }
+}
+
+#if 0
+static ext_grs_match_op_t **emit_negative_plans(ext_grs_action_t *act)
+{
+       lc_list_t *pos;
+       /* Compute a search plan for all negative patterns */
+       /* Count number of negative patterns */
+       int num_negatives = 0, i;
+       ext_grs_match_op_t **result;
+
+
+
+       lc_list_for_each(pos, (&act->negatives))
+               num_negatives++;
+
+       result = (ext_grs_match_op_t **) malloc(num_negatives * sizeof(ext_grs_match_op_t *));
+
+       i = 0;
+       /* Handle all negative patterns, there can be several */
+       lc_list_for_each(pos, (&act->negatives))
+       {
+               struct ext_grs_graph_t *neg_pattern;
+
+               result[i] = (ext_grs_match_op_t *) malloc((act->n_nodes + act->n_edges + act->n_conditions) * sizeof(ext_grs_match_op_t));
+               neg_pattern = lc_list_entry(pos, ext_grs_graph_t, negative_list);
+
+               /* TODO: Now walk through that graph and create search plan */
+
+
+               i++;
+       }
+       return(result);
+}
+#endif
+
+
+/* ---------------------------------------------------------
+   Allocate the memory for the plan object and for the array
+   representing the match program all at once
+   --------------------------------------------------------- */
+static ext_grs_match_plan_t *alloc_plan(ext_grs_action_t *act)
+{
+       ext_grs_match_plan_t *plan;
+       lc_list_t *neg_patterns;
+       lc_list_t *list_pos;
+       int num_negatives = 0, num_all_plans;
+       int i;
+
+       plan = malloc(sizeof(*plan));
+       memset(plan, 0, sizeof(*plan));
+       plan->action = act;
+
+
+       /* Compute a search plan for all negative patterns */
+
+       /* Count number of negative patterns */
+       lc_list_for_each(list_pos, (&act->negatives))
+               num_negatives++;
+       num_all_plans = num_negatives + 1;
+
+       plan->progs = (ext_grs_match_op_t **) malloc(num_all_plans * sizeof(ext_grs_match_op_t *));
+
+       /* Alloc mem for all search plans, 1 positive and n negative */
+       plan->progs[0] = (ext_grs_match_op_t *) malloc((act->n_nodes + act->n_edges + act->n_neg_nodes + act->n_neg_edges + act->n_conditions) * sizeof(ext_grs_match_op_t));
+       memset(plan->progs[0], 0, (act->n_nodes + act->n_edges + act->n_neg_nodes + act->n_neg_edges + act->n_conditions) * sizeof(ext_grs_match_op_t));
+
+
+       neg_patterns = &act->negatives;
+       neg_patterns = neg_patterns->next;
+       for(i = 1; i < num_all_plans; i++)
+       {
+               ext_grs_graph_t *pat = (ext_grs_graph_t *) lc_list_entry(neg_patterns, ext_grs_graph_t, negative_list);
+               plan->progs[i] = (ext_grs_match_op_t *) malloc((act->n_nodes + act->n_edges + act->n_neg_nodes + act->n_neg_edges + act->n_conditions) * sizeof(ext_grs_match_op_t));
+               memset(plan->progs[i], 0, (act->n_nodes + act->n_edges + act->n_neg_nodes + act->n_neg_edges + act->n_conditions) * sizeof(ext_grs_match_op_t));
+               neg_patterns = neg_patterns->next;
+       }
+
+
+       plan -> prog = plan -> progs[0];
+
+       plan -> length = (int *) malloc(num_all_plans * sizeof(int));
+       memset(plan -> length, 0, num_all_plans * sizeof(int));
+
+       plan->num_progs = num_all_plans;
+
+       return(plan);
+}
+
+
+
+/*
+ * Generation of the matching plan usind the precoomputed MDST.
+ * HERE WE GO: comming from the root chose one edge after another as the
+ *             next search plan edge by a modified Best-First manner:
+ *             An edge can only be chosen iff
+ *              - if it is an pseudo or benuine OUT edge AND
+ *              - at least one of its incident nodes has already
+ *                been visited by the final plan generation AND
+ *              - it is part of the computed MDSR or BOTH of
+ *                its incident nodes have already been chosen
+ * This is done by one big Priority queue were all edges
+ * are put in the moment they become allowed to be chosen */
+static int
+emit_plan( ext_grs_match_op_t *prog /*ext_grs_match_plan_t *plan*/, ext_grs_graph_t *pattern /*ext_grs_action_t *act*/, ext_grs_vs_dmst_planer_private_t *p, int phase)
+{
+       ext_grs_action_t *act = pattern->action;
+       ext_grs_node_t *current_node;
+       int j = 0;
+
+       /* create the pq containing the allowed edges */
+       /* a priority queue for edges used after MDST computation in
+        * the final plan generation step  */
+       ext_grs_mpq_t *edge_queue = ext_grs_mpq_create();
+       /* initialize the uf structure. This is because after the init
+        * a zero cost modification of incoming edges is associated to
+        * every pattern node. This MUST be done, because the cost
+        * modification stored on the if structure are used by the priority
+        * queue by to compute the actual cost of an edge. So if these
+        * modifications are NOT zero the order in the queue will be WRONG!!! */
+       ext_grs_uf_init(act->max_node_aiid + 1);
+
+
+       /* the current pos in the generated match program */
+
+
+       /* START from the patterns root */
+       current_node = &pattern->root_node;
+       while (1) {
+               lc_list_t *pos;
+               ext_grs_edge_t *cheapest_edge;
+               ext_grs_match_op_t *mop;
+
+               /* put all out (that is in-flowing) edges in pq that are allowed
+                * to be matched by the fact, that they belong to the MDST */
+               lc_list_for_each(pos, & current_node->edges[ext_grs_in]) {
+
+                       /* ATTENTION: if ported to GrGen these 'in' indeces have
+                        *            to be changed to 'out' !!!! */
+                       ext_grs_edge_t *some_edge =
+                               lc_list_entry(pos, ext_grs_edge_t, list[ext_grs_in]);
+
+                       if (
+                               /* some edge belongs to the MDST, but no match opereation
+                                * has been generated yet */
+                               p->chosen[some_edge->aiid] == 1
+                       )
+                       {
+                               ext_grs_mpq_insert(edge_queue, some_edge);
+                               /* mark edge as processed
+                                * (so it will not be inserted in the queue again) */
+                               p->chosen[some_edge->aiid] = 2;
+                       }
+               }
+               /* put all out (that is in-flowing) AND in (that is out-flowing)
+                * edges in pq that are allowed to be matched by the fact,
+                * that both of their incident nodes have already been matched.
+                * The in edges are added too, because the matching of the REAL
+                * edge coming from the (already matched) node at the other end
+                * of the plan graph edge may be cheaper */
+               lc_list_for_each(pos, & current_node->edges[ext_grs_in]) {
+
+                       /* ATTENTION: if ported to GrGen these 'in' indeces have
+                        *            to be changed to 'out' !!!! */
+                       ext_grs_edge_t *some_edge =
+                               lc_list_entry(pos, ext_grs_edge_t, list[ext_grs_in]);
+
+                       if (
+                               /* both incident nodes of some edge have arealready been
+                                * processed by the final plan genration phase, but no match
+                                * operation has been generated yet */
+                               (p->chosen[some_edge->aiid] == 0 && p->visited[some_edge->arg->aiid] > phase)
+                       )
+                       {
+                               ext_grs_mpq_insert(edge_queue, some_edge);
+                               /* mark edge as processed
+                                * (so it will not be inserted in the queue again) */
+                               p->chosen[some_edge->aiid] = 2;
+
+
+                               /* also insert the backward edge */
+                               /* ...in case of a real edge its in fact the backward edge */
+                               if (some_edge->kind == ext_grs_k_edge) {
+                                       ext_grs_mpq_insert(edge_queue, some_edge->backward_edge);
+                                       p->chosen[some_edge->backward_edge->aiid] = 2;
+                               }
+                               /* ...otherwise its the genuine edge */
+                               else {
+                                       assert (some_edge->kind == ext_grs_k_pseudo_edge && "invalid kind");
+                                       if (some_edge->genuine_elem.kind == ext_grs_k_edge) {
+                                               ext_grs_edge_t *genuine_edge = some_edge->genuine_elem.val.e;
+                                               ext_grs_mpq_insert(edge_queue, genuine_edge);
+                                               p->chosen[genuine_edge->aiid] = 2;
+                                       }
+                                       else {
+                                               /* just check for wrong kind and do nothing */
+                                               assert (some_edge->genuine_elem.kind == ext_grs_k_node && "invalid kind");
+                                       }
+                               }
+                       }
+               }
+
+               /* get the cheapest edge */
+               cheapest_edge = ext_grs_mpq_delete_min(edge_queue);
+               if (cheapest_edge == NULL) break;/* if all edges processed... */
+
+               assert(j < (act->n_nodes + act->n_edges + act->n_neg_edges + act->n_neg_nodes + act->n_conditions) && "prog position out of bounds");
+
+               /* add new match op to the plan */
+               mop = & prog[j];
+
+               if (p->visited[cheapest_edge->arg->aiid] <= phase)
+                       cheapest_edge->arg->first_mop_index = j;
+
+               /* mark the target node of the edge as visited */
+               p->visited[cheapest_edge->arg->aiid] = phase + 1;
+
+
+               emit_mop(p, act, prog, cheapest_edge, &j);
+
+               /* increment the pos in the match program */
+               j++;
+               /* increment the length of the search plan */
+               /*plan->length++; */
+               /* the next node to insert allowed incident out edges in the queue */
+               current_node = cheapest_edge->arg;
+       }
+       return (j);
+}
+
+/* annotate the edges of the plan graph with edge costs due to the
+ * result of a previous v-structure analysis */
+static void annotate_edge_costs(
+       ext_grs_graph_t *pattern /*ext_grs_action_t *act*/, ext_grs_irg_private_t *pr_g, ext_grs_vs_stat_t *vs_stat, int is_negative)
+{
+
+       /*int i; */
+
+       /* annotate all real, negative and pseudo edges with edge costs
+        * additionally do some init stuff with each edge */
+       lc_list_t *pos;
+
+       /* Go through all edges of this pattern */
+       lc_list_for_each(pos, &pattern->edges)
+       {
+       /*for (i = 0; i <= act->max_edge_aiid; i++) { */
+
+               ext_grs_edge_t *edge = lc_list_entry(pos, ext_grs_edge_t, edge_list); /*act->edges[i]; */
+
+               ir_opcode opc_arg;
+               modecode mc_arg;
+               ir_opcode opc_func;
+               modecode mc_func;
+               ir_opcode opc;
+               modecode mc;
+
+               int l;
+
+               /* there might be gaps in the array of edges */
+               /*if (!edge) continue; */
+               assert(edge != NULL && "Edge was NULL!");
+
+               /* for regular and pseudo edges annotate the v-structure costs */
+               if (edge->kind == ext_grs_k_edge) {
+                       double n_vs;
+                       int n_inst = 0;
+
+
+                       opc_arg = get_op_code(edge->arg->op);
+                       mc_arg = get_mode_modecode(edge->arg->mode);
+                       opc_func = get_op_code(edge->func->op);
+                       mc_func = get_mode_modecode(edge->func->mode);
+
+
+
+                       /* get v-structures of the function node */
+
+                       /* compute the number of instnaces present for the
+                        * func node (including all sub ops) */
+                       for (l = 0; l < ARR_LEN(_ext_grs_all_sub_ops_of_op[opc_func]); l++) {
+                               ir_opcode super_opc_func = get_op_code(_ext_grs_all_sub_ops_of_op[opc_func][l]);
+                               n_inst += _ext_grs_N_INSTANCES(pr_g, super_opc_func, mc_func);
+                       }
+
+                       edge->cost = 0.0;
+                       if (edge->pos == ext_grs_NO_EDGE_POS)
+                               if (n_inst != 0) {
+                                       n_vs = _get_n_v_structures(
+                                                               vs_stat, opc_func, mc_func, opc_arg, mc_arg, ext_grs_in);
+                                       edge->cost = (n_vs / (double)n_inst) + (double)is_negative;
+                               }
+               }
+
+               /* for pseudo edges... */
+               else {
+                       ext_grs_elem_t *elem;
+                       assert(edge->kind == ext_grs_k_pseudo_edge && "invalid kind found");
+
+                       /* ...find out, whether they represent a node matching or the
+                        * following of an edge in reverse direction */
+                       elem = & edge->genuine_elem;
+                       /* to do that, check the kind tag, which is stored first */
+                       if ( elem->kind == ext_grs_k_node) {
+                               double log_n_instances;
+                               int n_inst = 0;
+
+                               opc = get_op_code(edge->arg->op);
+                               mc = get_mode_modecode(edge->arg->mode);
+                               /* the genuine elem the pseudo edge belongs to is a node... */
+                               /* thus the the costs are the log2 of the number of instances */
+
+                               /* compute the number of instances present for the
+                                * node (including all sub ops) */
+                               for (l = 0; l < ARR_LEN(_ext_grs_all_sub_ops_of_op[opc]); l++) {
+                                       ir_opcode super_opc = get_op_code(_ext_grs_all_sub_ops_of_op[opc][l]);
+                                       n_inst += _ext_grs_N_INSTANCES(pr_g, super_opc, mc);
+                               }
+
+                               if (n_inst > 0)
+                                       log_n_instances = _log2(n_inst);
+                               else log_n_instances = 0.0;
+                               edge->cost = log_n_instances + (double)is_negative;
+
+                               /* check (for negative graphs) whether the node is related to
+                                  a positive node; if so, set the costs of the pseudo edge to zero. */
+                               if (is_negative)
+                                       if (edge->arg->related_node)
+                                               edge->cost = 0.0;
+                       }
+                       else {
+                               double n_vs;
+                               int n_inst = 0;
+                               opc_arg = get_op_code(edge->arg->op);
+                               mc_arg = get_mode_modecode(edge->arg->mode);
+                               opc_func = get_op_code(edge->func->op);
+                               mc_func = get_mode_modecode(edge->func->mode);
+
+                               /* the genuine elem the pseudo edge belongs to is an edge... */
+                               assert(elem->kind == ext_grs_k_edge && "pattern elem of a wrong kind");
+
+                               /* get v-structures of the argument node */
+                               n_vs = _get_n_v_structures(
+                                               vs_stat, opc_func, mc_func, opc_arg, mc_arg, ext_grs_out);
+
+                               /* compute the number of instances present for the
+                                * func node (including all sub ops) */
+                               for (l = 0; l < ARR_LEN(_ext_grs_all_sub_ops_of_op[opc_func]); l++) {
+                                       ir_opcode super_opc_func = get_op_code(_ext_grs_all_sub_ops_of_op[opc_func][l]);
+                                       n_inst += _ext_grs_N_INSTANCES(pr_g, super_opc_func, mc_func/* MAYBE WRONG!!! */ );
+                               }
+
+                               if (n_inst != 0)
+                                       edge->cost = n_vs / (double)n_inst;
+                               else
+                                       edge->cost = 0.0;
+
+                               edge->cost += (double)is_negative;
+                       }
+               }
+       }
+}
+
+static void prepare_mdst_contraction_phase(
+       /*ext_grs_action_t *act*/ext_grs_graph_t *pattern, lc_list_t *not_visited_nodes, ext_grs_mpq_t **pq)
+{
+       lc_list_t *pattern_pos;
+       int i;
+
+       /* for all pattern nodes v do:
+        *              - create a pq(v), put all the nodes edges in pq(v)
+        *      - add v to the list of not yet processed nodes */
+       LC_INIT_LIST_HEAD(not_visited_nodes);
+
+       lc_list_for_each(pattern_pos, &pattern->nodes)
+       {
+       /*for (i = 0; i <= act->max_node_aiid; i++) {*/
+
+               lc_list_t *pos;
+
+
+               ext_grs_node_t *current_node = lc_list_entry(pattern_pos, ext_grs_node_t, node_list); /*act->nodes[i];*/
+               i = current_node->aiid;
+
+               /* there might be gaps in the array of nodes */
+               /*if (!current_node)
+                       continue;*/
+
+               assert(current_node != 0 && "NULL Node in node List!!");
+
+               /*assert(current_node->aiid == i && "found node with an inconsistent action internal id"); */
+               /* create a new pq for each pattern node */
+               pq[i] = ext_grs_mpq_create();
+               /* fill the new pq with all graph theoretical incoming
+                * edges of the node, i.e. with all out-flowing edges */
+               lc_list_for_each(pos, & current_node->edges[ext_grs_out]) {
+                       ext_grs_edge_t *current_edge =
+                               lc_list_entry(pos, ext_grs_edge_t, list[ext_grs_out]);
+                       ext_grs_mpq_insert(pq[i], current_edge);
+               }
+
+               /* add the current node to a list of nodes not yet
+                * processed by Edmonds Algor. */
+               lc_list_add(& current_node->not_visited_list, not_visited_nodes);
+       }
+}
+
+static ext_grs_edge_t *
+process_found_circle(
+       ext_grs_graph_t *pattern, ext_grs_vs_dmst_planer_private_t *p, ext_grs_mpq_t **pq,
+       ext_grs_node_t *start_node, int phase)
+{
+       ext_grs_action_t *act = pattern->action;
+       ext_grs_node_t *current_node = start_node;
+
+       /* the current circle node */
+       ext_grs_node_t *circle_node;
+
+       ext_grs_edge_t *cheapest_edge;
+       ext_grs_edge_t *current_edge;
+       int node_id;
+
+
+       /* an auxilary pq item */
+       ext_grs_mpq_t *meld_pq;
+
+       /* the first edge of the edges forming the circle, the last edge forming the
+        * circle (both seen in edge direction) and the edge processed before processing
+        * the last edge */
+       ext_grs_edge_t *first_circle_edge, *last_circle_edge, *from_edge;
+
+       /* cheapest edge of the new made super node, it is incident
+        * to the same node as kill edge */
+       ext_grs_edge_t *continue_edge;
+       /* the repsective incident incomming circle edge */
+       ext_grs_edge_t *current_end_edge;
+
+       /* check for a consistent uf state */
+       assert(p->visited[current_node->aiid] == phase && "visited by a future phase?!");
+
+
+
+       /* walk the circle and unite all (super)nodes uf sets. By uniting
+        * the uf structure a second walk through the circle can find out
+        * the cheapest edge entering the super node formed by the
+        * current circle, such that this cheapest edge is not a loop edge. */
+/*
+#ifdef EXT_GRS_DEBUG
+       printf("Walk circle the 1st time. The processed edges are:\n");
+#endif
+ */
+       cheapest_edge = ext_grs_mpq_delete_min(pq[current_node->aiid]);
+       assert(cheapest_edge && "there should have been a circle edge");
+
+/*
+       #ifdef EXT_GRS_DEBUG
+               printf("  %s\n", cheapest_edge->name);
+       #endif
+ */
+
+       /* the first of the processed cheapest edges is the last circle edge
+        * followinf the edge direction (as the last of these edge is the
+        * first circle edge in edge direction) */
+       last_circle_edge = cheapest_edge;
+       /* the edge processed before processing the last circle edge for
+        * the first time */
+       from_edge = p->edge_path_succ[last_circle_edge->aiid];
+
+       /* store the pq of the cheapest edges target (super)node temporarily
+        * in the real target node of the cheapest edge */
+       pq[cheapest_edge->arg->aiid] = pq[current_node->aiid];
+
+       /* get the minimal cost edges source (super) node */
+       node_id = UF_FIND(cheapest_edge->func->aiid);
+       assert(node_id <= act->max_node_aiid && "node id found in uf structure to large");
+       circle_node = act->nodes[node_id];
+
+       /* check wether all circle nodes have been visited in the current phase */
+       assert(p->visited[circle_node->aiid] == phase &&
+               "all nodes of a circle should have been visited in the same phase");
+
+       /* store modification of incoming edge costs in node */
+       UF_CHANGE_VALUE(
+               current_node->aiid,
+               cheapest_edge->cost - UF_FIND_VALUE(cheapest_edge->arg->aiid)
+       );
+
+       while (circle_node != current_node) { /* walk the hole circle */
+
+               /* get a minimum cost edge of some_node, this edge must be the
+                * first edge of the circle because the priviously chosen one
+                * remains to be the first elem of the double linked lists */
+               cheapest_edge = ext_grs_mpq_delete_min(pq[circle_node->aiid]);
+/*
+               #ifdef EXT_GRS_DEBUG
+                       printf("  %s\n", cheapest_edge->name);
+               #endif
+ */
+               /* check: there is a cheapest edge and as a circle edge it
+                * has to be a chosen one */
+               assert(cheapest_edge && "there should have been a circle edge");
+
+               /* store the pq of the cheapest edges target (super)node temporarily
+                * in the real target node of the cheapest edge */
+               pq[cheapest_edge->arg->aiid] = pq[circle_node->aiid];
+
+               /* store the change of the costs of the incoming edges of
+                * the current circle node as value in the nodes uf structure */
+               UF_CHANGE_VALUE(
+                       circle_node->aiid,
+                       cheapest_edge->cost - UF_FIND_VALUE(cheapest_edge->arg->aiid)
+               );
+
+               /* unite circle nodes to a super node */
+               node_id = UF_UNITE(circle_node->aiid, current_node->aiid);
+               /* ensure that the next node is united super node */
+               current_node = act->nodes[node_id];
+
+               /* get ready for the next iteration step... */
+               /* ...and the current one to the tgt node of the cheapest edge */
+               node_id = UF_FIND(cheapest_edge->func->aiid);
+               assert(node_id < act->n_nodes + act->n_neg_nodes + act->n_pseudo_nodes && "node id found in uf structure to large");
+               circle_node = act->nodes[node_id];
+
+               /* check wether all circle nodes have been visited in the current phase */
+               assert(p->visited[circle_node->aiid] == phase &&
+                       "all nodes of a circle should have been visited in the same phase");
+
+       }
+
+
+       /* the last of the processed cheapest edges is the first circle edge
+        * following the edge direction (as the first of these edge is the
+        * last circle edge in edge direction) */
+       first_circle_edge = cheapest_edge;
+
+       p->edge_path_succ[last_circle_edge->aiid] = first_circle_edge;
+
+
+
+
+       /* walk the circle again, this time using the stored edge path.
+        * while walking the circle look for the cheapest incomming edge
+        * which is not a loop. The loop property can be checked using
+        * the already united uf sets representing the (super)nodes */
+/*
+       #ifdef EXT_GRS_DEBUG
+               printf("Walk circle the 2nd time. The processed edges are:\n");
+       #endif
+ */
+
+       meld_pq = pq[last_circle_edge->arg->aiid];
+       current_edge = first_circle_edge;
+
+       continue_edge = ext_grs_mpq_find_min( meld_pq );
+       assert (continue_edge && "there's always an edge from the root node");
+       while (
+               UF_FIND(continue_edge->func->aiid) == current_node->aiid  &&
+               continue_edge->func != &pattern->root_node
+       )
+       {
+               /* a loop edge has to be deleted... */
+               ext_grs_mpq_delete_min( meld_pq );
+               /* ...and a new minimal one has to be chosen */
+               continue_edge = ext_grs_mpq_find_min( meld_pq );
+               assert (continue_edge != NULL && "there's always an edge from the root node");
+       }
+       current_end_edge = last_circle_edge;
+
+
+       while (current_edge != last_circle_edge) {
+
+               ext_grs_edge_t *some_edge = continue_edge;
+
+               meld_pq =  ext_grs_mpq_meld(pq[current_edge->arg->aiid], meld_pq);
+
+               continue_edge = ext_grs_mpq_find_min( meld_pq );
+               assert (continue_edge && "there's always an edge from the root node");
+               while (
+                       UF_FIND(continue_edge->func->aiid) == current_node->aiid  &&
+                       continue_edge->func != &pattern->root_node
+               )
+               {
+                       /* a loop edge has to be deleted... */
+                       ext_grs_mpq_delete_min( meld_pq );
+                       /* ...and a new minimal one has to be chosen */
+                       continue_edge = ext_grs_mpq_find_min( meld_pq );
+                       assert (continue_edge != NULL && "there's always an edge from the root node");
+               }
+               /* if continue_edge has changed... */
+               if (some_edge != continue_edge) {
+                       some_edge = continue_edge;
+                       current_end_edge = current_edge;
+               }
+
+               current_edge = p->edge_path_succ[current_edge->aiid];
+/*
+               #ifdef EXT_GRS_DEBUG
+                       printf("  %s\n", current_edge->name);
+               #endif
+ */
+
+       }
+
+       /* store the melded pq as new pq of the super node in the representative
+        * node of the super node. */
+       pq[current_node->aiid] = meld_pq;
+
+
+
+
+
+       p->edge_path_succ[continue_edge->aiid] = from_edge;
+       p->super_node_last_edge[continue_edge->aiid] = current_end_edge;
+
+
+       /* continue with cheapest edge leaving the circle */
+       return continue_edge;
+}
+
+
+/* First phase of the MDST computation: contract all circles in
+ * the plangraph to super nodes */
+static int mdst_contraction_phase(ext_grs_graph_t *pattern, ext_grs_vs_dmst_planer_private_t *p)
+{
+
+       ext_grs_action_t *act = pattern->action;
+       /* a list of nodes not yet processed by Edmonds Algo */
+       lc_list_t not_visited_nodes;
+       /* needed for walking the list of unprocessed nodes */
+       lc_list_t *pos;
+
+       /* an array of meldable priority queues. Each mpq
+        * will contain the edges of the node the id of which equals the
+        * index in the mpq array. The edge costs will serve as key. */
+       ext_grs_mpq_t **pq = alloca((act->max_node_aiid + 1) * sizeof(*pq));
+       /* the current pattern node */
+       ext_grs_node_t *current_node;
+       /* visit phases of the contraction phase */
+       int phase = 1;
+
+
+       memset(pq, 0, (act->max_node_aiid + 1) * sizeof(*pq));
+
+
+       prepare_mdst_contraction_phase(pattern, & not_visited_nodes, pq);
+
+
+       #ifdef EXT_GRS_DEBUG
+               printf(">>>> The MDST contraction phase: <<<<\n");
+       #endif
+
+
+
+       while (! lc_list_empty(& not_visited_nodes))
+       {
+
+               /* a minimum cost edge */
+               ext_grs_edge_t *cheapest_edge;
+               /* be minimum cost edge processed in the last step */
+               ext_grs_edge_t *previous_edge = NULL;
+
+               pos = not_visited_nodes.next;
+
+
+               current_node = lc_list_entry(pos, ext_grs_node_t, not_visited_list);
+               #ifdef EXT_GRS_DEBUG
+                       printf("\nTaking a not yet visited node: %s\nChoosing edges: ", current_node->name);
+               #endif
+
+               /* mark the current node as visited (with the number of the
+                * corresponding visit phase)... */
+               p->visited[current_node->aiid] = phase;
+               /* del the current node from the list of unvisited nodes */
+               lc_list_del( & current_node->not_visited_list);
+
+               cheapest_edge = ext_grs_mpq_find_min(pq[current_node->aiid]);
+               p->edge_path_succ[cheapest_edge->aiid] = NULL;
+
+               #ifdef EXT_GRS_DEBUG
+                       printf("\n%s ", cheapest_edge->name);
+               #endif
+
+
+               /* Edmonds Algo unites nodes to super nodes, thus the number
+                * of nodes decreases, further more the root node has no incomming
+                * (that is out-flow) edges, thus in that case one has to start with
+                * another not yet visited node */
+               /* note that root node has no in-edges (that is out-flow edges) */
+               while (1) {
+
+                       /* an auxilary id */
+                       int node_id;
+
+                       assert (cheapest_edge != NULL && "every node except the root has an incomming edge");
+
+                       /* if tgt node of the cheapest edge is the root,
+                        * try another not yet visited node */
+                       if (cheapest_edge->func == & pattern->root_node) {
+                               p->edge_path_roots[p->n_edge_path_roots++] = cheapest_edge;
+                               break;
+                       }
+
+                       /* find the next current node to choose a cheapest incoming edge from */
+                       node_id = UF_FIND(cheapest_edge->func->aiid);
+                       assert (node_id < act->n_nodes + act->n_neg_nodes + act->n_pseudo_nodes && "node id found in uf structure to large");
+                       current_node = act->nodes[node_id];
+
+                       /* check wether the src node of the minimal cost edge has already been
+                        * visited, and if so wether this has happend in a previous or in current
+                        * visit phase */
+                       if (p->visited[current_node->aiid] == 0) {/* not visited yet... */
+
+                               previous_edge = cheapest_edge;
+
+                               cheapest_edge = /* ...so get the next cheapest edge... */
+                                       ext_grs_mpq_find_min(pq[current_node->aiid]);
+
+                               #ifdef EXT_GRS_DEBUG
+                                       printf("%s ", cheapest_edge->name);
+                               #endif
+
+                               p->edge_path_succ[cheapest_edge->aiid] = previous_edge;
+
+                               /* mark current node as visited by the current visit phase */
+                               p->visited[current_node->aiid] = phase;
+                               /* remove the node from the list of unvisited nodes */
+                               lc_list_del( & current_node->not_visited_list);
+                               continue; /* ...and go on further */
+                       }
+                       else if (current_node->aiid == UF_FIND(cheapest_edge->arg->aiid)) { /* a loop edge found */
+                               /* remove every found loop from the (super)nodes pq */
+                               ext_grs_mpq_delete_min(pq[current_node->aiid]);
+
+                               #ifdef EXT_GRS_DEBUG
+                                       printf("Loop!");
+                               #endif
+
+                               cheapest_edge = ext_grs_mpq_find_min(pq[current_node->aiid]);
+
+                               #ifdef EXT_GRS_DEBUG
+                                       printf("%s ", cheapest_edge->name);
+                               #endif
+
+                               p->edge_path_succ[cheapest_edge->aiid] = previous_edge;
+                               continue;
+                       }
+                       else if (p->visited[current_node->aiid] < phase) { /* visited in a previous phase... */
+                               p->edge_path_roots[p->n_edge_path_roots++] = cheapest_edge;
+                               break; /* ...so start from a nother not yet visited node */
+                       }
+                       else {
+
+                               #ifdef EXT_GRS_DEBUG
+                                       printf("Circle! ");
+                               #endif
+
+                               /* a circle has been formed */
+                               cheapest_edge = process_found_circle(pattern, p, pq, current_node, phase);
+
+                               #ifdef EXT_GRS_DEBUG
+                                       printf("Cheapest outgoing edge: %s\n", cheapest_edge->name);
+                               #endif
+
+                               previous_edge = p->edge_path_succ[cheapest_edge->aiid];
+
+                       }
+               }
+               /* next visit phase has a greater marking number, that means that
+                * we can decide in O(1) wether this node belongs to a circle
+                * or has reverse a path to the root node of the current action */
+               phase++;
+       }
+
+       return phase;
+}
+
+
+/* Second phase of the MDST computation: expand the condensed super nodes
+ * and choose an appropriate entering edge of each super node expanded */
+static void mdst_expansion_phase(ext_grs_vs_dmst_planer_private_t *p) {
+
+       int i;
+       ext_grs_edge_t *current_edge;
+
+       #ifdef EXT_GRS_DEBUG
+               printf("\n>>>> The MDST expansion phase: <<<<\n");
+               printf("Top level: ");
+       #endif
+
+
+       /* for all edge paths found, do... */
+       for (i = 0; i < p->n_edge_path_roots; i++) {
+
+               ext_grs_edge_t *end_edge;
+               ext_grs_edge_t *start_edge;
+
+               /* walk the hole edge path till it ends */
+               current_edge = p->edge_path_roots[i];
+               while (current_edge != NULL) {
+
+                       assert(p->mdst_reached[current_edge->arg->aiid] == 0 &&
+                               "there should be no circles on top level");
+
+                       #ifdef EXT_GRS_DEBUG
+                               printf("%s ", current_edge->name);
+                       #endif
+
+
+                       /* follow the edge path until the target node of the current
+                        * edge is a super node and mark the real target nodes of the
+                        * edge path as already reached by an MDST edge (this is because
+                        * on the top level the edge do NOT belong to a super node, thus
+                        * all super nodes on the current edge path have exactly ONE ocomming
+                        * edge, and this edge must be chosen for the MDST!) */
+                       p->chosen[current_edge->aiid] = 1;
+                       p->mdst_reached[current_edge->arg->aiid] = 1;
+
+                       /* if the current edges target node is a super node, expand this super node! */
+                       end_edge = p->super_node_last_edge[current_edge->aiid];
+                       if (end_edge) {
+                               start_edge = p->edge_path_succ[end_edge->aiid];
+                               expand_super_node(p, start_edge);
+                       }
+
+                       /* process the next edge on the current edge path */
+                       current_edge = p->edge_path_succ[current_edge->aiid];
+               }
+
+       }
+}
+
+
+
+
+static void init(ext_grs_planer_t *planer, ext_grs_analyzer_t *alz) {
+       planer->analyzer = alz;
+}
+
+
+
+
+static ext_grs_match_plan_t *compute_plan(
+       ext_grs_planer_t *planer, ir_graph *irg, ext_grs_action_t *act)
+{
+
+       lc_list_t *neg_pattern;
+       /* the private data area of the planer */
+       ext_grs_vs_dmst_planer_private_t *p = (ext_grs_vs_dmst_planer_private_t *) planer->data;
+       /* the plan to be returned */
+       ext_grs_match_plan_t *plan;
+       int i;
+
+       /* keeps the number of the visit phase of the Edmonds MDST impl */
+       int phase;
+
+
+       /* Alloc memory for plan object and positive and negative search plan progs */
+       plan = alloc_plan(act);
+
+
+
+       /* init bitsets needed to store information needed in emitting condition  */
+       p->already_placed_conditions = lc_bitset_alloca(act->n_conditions);
+       p->already_matched_nodes =  lc_bitset_alloca(act->max_node_aiid+1);
+       p->already_matched_edges =  lc_bitset_alloca(act->max_edge_aiid+1);
+
+       p->edge_path_succ = alloca((act->max_edge_aiid + 1) * sizeof(* p->edge_path_succ));
+       p->super_node_last_edge = alloca((act->max_edge_aiid + 1) * sizeof(* p->super_node_last_edge));
+
+       p->visited = alloca((act->max_node_aiid + 1) * sizeof(*p->visited));
+       /* tells wether an edge has been chosen */
+       p->chosen = alloca((act->max_edge_aiid + 1) * sizeof(* p->chosen));
+       /* tells wether a node has been already reached by the MDST */
+       p->mdst_reached = alloca((act->max_node_aiid + 1) * sizeof(* p->mdst_reached));
+
+       p->edge_path_roots = alloca((act->max_edge_aiid + 1) * sizeof(*p->edge_path_roots));
+
+
+
+
+       if (act->mature == 0) {
+               printf("ERROR in module ext/grs: invoked planing for a nonmature action\n");
+               return NULL;
+       }
+
+       /* for an empty pattern return an empty plan */
+       if (act->n_nodes + act->n_neg_nodes <= 0) {
+               plan = (ext_grs_match_plan_t *) malloc(sizeof(*plan));
+               memset(plan, 0, sizeof(*plan));
+               plan->action = act;
+               plan->length[0] = 0;
+               plan->prog = NULL;
+               plan->progs = 0;
+               plan->num_progs = 0;
+               return plan;
+       }
+
+
+       /* Compute Progs for all patterns (positive and negative) */
+
+       /* act->negatives is the list head, call next node to find the first object in list */
+       neg_pattern = &act->negatives;
+       neg_pattern = neg_pattern->next;
+       for(i = 0; i < plan->num_progs; i++)
+       {
+               /* the current positive or negayive pattern graph */
+               ext_grs_graph_t *pat;
+
+               /* do some init */
+               memset(p->visited, 0, (act->max_node_aiid + 1) * sizeof(* p->visited));
+               memset(p->chosen, 0, (act->max_edge_aiid + 1) * sizeof(* p->chosen));
+               memset(p->mdst_reached, 0, (act->max_node_aiid + 1) * sizeof(* p->mdst_reached));
+               memset(p->edge_path_succ, 0, (act->max_edge_aiid + 1) * sizeof(* p->edge_path_succ));
+               memset(p->super_node_last_edge, 0, (act->max_edge_aiid + 1) * sizeof(* p->super_node_last_edge));
+               memset(p->edge_path_roots, 0, (act->max_edge_aiid + 1) * sizeof(*p->edge_path_roots));
+               p->n_edge_path_roots = 0;
+
+               /* init the mpq structure */
+               ext_grs_mpq_init();
+
+               /* Init the union find structure used to represent the united nodes
+               * used by an implementation of Edmond's MDST-Algorithm used in this
+               * planning procedure. Nodes and united nodes are represented by
+               * node ids which are the elements of the union find structure */
+               ext_grs_uf_init(act->max_node_aiid + 1);
+
+               /* annotate the plan graph with edge costs due to the analysis
+               * results stored by the analyzer registered with the given
+               * planer */
+
+
+               /* first phase of the MDST computation: contract the all circles in the
+               * plan graph to super nodes */
+
+               if(i == 0)
+               {
+                       pat = act->pattern;
+                       annotate_edge_costs(pat, _ext_grs_get_irg_private(irg), _get_irg_vs_stat(planer->analyzer, irg), 0);
+                       phase = mdst_contraction_phase(pat, p);
+               }
+               else
+               {
+                       pat = (ext_grs_graph_t *) lc_list_entry(neg_pattern, ext_grs_graph_t, negative_list);
+                       annotate_edge_costs(pat, _ext_grs_get_irg_private(irg), _get_irg_vs_stat(planer->analyzer, irg), 1);
+                       phase = mdst_contraction_phase(pat, p);
+                       neg_pattern = neg_pattern->next;
+               }
+
+               /* second phase of the MDST computation: expand the condensed super nodes
+               * and choose an appropriate entering edge of each super node expanded */
+               mdst_expansion_phase(p);
+
+       #ifdef EXT_GRS_DEBUG
+               {
+                       /* dump the MDST */
+                       double c = 0;
+                       int i;
+                       printf("dump the MDST: name, aiid, acc_cost\n");
+                       for (i = 0; i <= act->max_edge_aiid; i++)
+                               if (act->edges[i])
+                                       if (
+                                               (act->edges[i]->kind == ext_grs_k_edge && act->edges[i]->graph == pat) ||
+                                               (act->edges[i]->kind == ext_grs_k_pseudo_edge && act->edges[i]->genuine_elem.val.e->graph == pat)
+                                               )
+                                               if (p->chosen[ act->edges[i]->aiid ]) {
+                                                       c += act->edges[i]->cost;
+                                                       printf("edge %s, %d, %lf\n", act->edges[i]->name, act->edges[i]->aiid, c);
+                                               }
+                       printf("\n");
+               }
+       #endif
+
+               /* The MDST is now computed (all edges with chosen[edge->id] != 0 belong
+               * to the MDST). Now the final plan generation can be done */
+
+               /* Compute search plans for positive and negative pattern */
+               plan->length[i] = emit_plan(plan->progs[i], pat, p, phase);
+       }
+       return(plan);
+}
+
+
+
+
+
+
+
+
+/** yields an analyzer performing a v-structure statisitc */
+ext_grs_planer_t *ext_grs_get_vs_dmst_planer(void)
+{
+       ext_grs_planer_t *planer = malloc(sizeof(*planer));
+       planer->data = malloc( sizeof(ext_grs_vs_dmst_planer_private_t) );
+       planer->tag = "vs_dmst_planer";
+       planer->init = init;
+       planer->compute_plan = compute_plan;
+
+       return planer;
+}

diff --git a/ir/be/grgen/plan_vs_dmst.h b/ir/be/grgen/plan_vs_dmst.h
new file mode 100644 (file)
index 0000000..5412533
--- /dev/null
+++ b/ir/be/grgen/plan_vs_dmst.h
@@ -0,0 +1,8 @@
+#ifndef _EXT_GRS_PLAN_VS_DMST_H_
+#define _EXT_GRS_PLAN_VS_DMST_H_
+
+/** yields an analyzer performing a v-structure statisitc */
+ext_grs_planer_t *ext_grs_get_vs_dmst_planer(void);
+
+
+#endif /*_EXT_GRS_PLAN_VS_DMST_H_*/

diff --git a/ir/be/grgen/simd/C_Patterns/C_Patterns.c b/ir/be/grgen/simd/C_Patterns/C_Patterns.c
new file mode 100644 (file)
index 0000000..cb76c5a
--- /dev/null
+++ b/ir/be/grgen/simd/C_Patterns/C_Patterns.c
@@ -0,0 +1,352 @@
+/*****************************************************************************
+ * Program:  C_Patterns.c
+ * Function: C specification of complex operations for the simd optimization.
+ *                      The order in this file of the functions is IMPORTANT since an
+ *                      earlier defined function has a higher scheduling priority!
+ * Author:   Andreas Schoesser
+ * Date:     2007-02-13
+ *****************************************************************************/
+
+
+#include <stdio.h>
+#include "define_operation.h"
+
+typedef int sse_32_2;
+
+/* Vektor Load, 4 Komponents, single precision float */
+void vload_4f_32(void)
+{
+       float *param = Arg_0("vector", "memory", "gp");
+       float *result = Res("vector", "register", "xmm");
+       Emit(". movaps (%S0), %D0");
+       Priority(0);
+
+       result[0] = param[0];
+       result[1] = param[1];
+       result[2] = param[2];
+       result[3] = param[3];
+}
+
+
+
+void vload_16b(void)
+{
+       unsigned char *param  = Arg_0("vector", "memory", "gp");
+       unsigned char *result = Res("vector", "register", "xmm");
+       Emit(". lddqu (%S0), %D0");
+       Priority(0);
+       CostSavings(10);
+
+       result[0] = param[0];
+       result[1] = param[1];
+       result[2] = param[2];
+       result[3] = param[3];
+       result[4] = param[4];
+       result[5] = param[5];
+       result[6] = param[6];
+       result[7] = param[7];
+       result[8] = param[8];
+       result[9] = param[9];
+       result[10] = param[10];
+       result[11] = param[11];
+       result[12] = param[12];
+       result[13] = param[13];
+       result[14] = param[14];
+       result[15] = param[15];
+}
+
+
+
+#if 0
+/* Vektor Load, 4 Komponents, 32 Bit integer */
+void vload_4_32(void)
+{
+       sse_32_2 *param = Arg_0("vector", "memory", "gp");
+       sse_32_2 *result = Res("vector", "register", "xmm");
+       Emit(". movdqu (%S0), %D0");
+       Priority(0);
+
+       result[0] = param[0];
+       result[1] = param[1];
+       result[2] = param[2];
+       result[3] = param[3];
+}
+
+
+void vload_2_32(void)
+{
+       sse_32_2 *param = Arg_0("vector", "memory", "gp");
+       sse_32_2 *result = Res("vector", "register", "xmm");
+       Emit(". movq (%S0), %D0");
+       Priority(1);
+
+       result[0] = param[0];
+       result[1] = param[1];
+}
+
+
+void vadd_2_32(void)
+{
+       sse_32_2 *param0 = Arg_0("vector", "register", "xmm");
+       sse_32_2 *param1 = Arg_1("vector", "register", "xmm");
+       sse_32_2 *result = Res("vector", "register", "in_r0");
+       Emit(". paddd %S1, %S0");
+       Priority(2);
+
+
+       result[0] = param0[0] + param1[0];
+       result[1] = param0[1] + param1[1];
+}
+#endif
+
+/** Register mode **/
+void mulps_4_32(void)
+{
+       float *param0 = Arg_0("vector", "register", "xmm");
+       float *param1 = Arg_1("vector", "register", "xmm");
+       float *result = Res("vector", "register", "in_r1");
+       Emit(". mulps %S1, %S0");
+       Priority(2);
+
+       result[0] = param0[0] * param1[0];
+       result[1] = param0[1] * param1[1];
+       result[2] = param0[2] * param1[2];
+       result[3] = param0[3] * param1[3];
+}
+
+/** Mem mode right **/
+void mulps_4_32_am(void)
+{
+       float *param0 = Arg_0("vector", "register", "xmm");
+       float *param1 = Arg_1("vector", "memory",   "gp");
+       float *result = Res("vector", "register", "in_r1");
+       Emit(". mulps %S1, %S0");
+       Priority(0);
+       CostSavings(5);
+
+       result[0] = param0[0] * param1[0];
+       result[1] = param0[1] * param1[1];
+       result[2] = param0[2] * param1[2];
+       result[3] = param0[3] * param1[3];
+}
+
+
+
+void add_horz_4_32(void)
+{
+       float *param = Arg_0("vector", "register", "xmm");
+       float *result = Res("vector", "register", "in_r1");
+       Emit(". haddps %S0, %S0\\n. haddps %S0, %S0");
+       Priority(2);
+
+       result[0] = param[0] + param[1] + param[2] + param[3];
+}
+
+
+ /************************************************************************/
+ /*                                                                      */
+ /************************************************************************/
+
+void maxps(void)
+{
+       float *a = Arg_0("vector", "register", "xmm");
+       float *b = Arg_1("vector", "register", "xmm");
+       float *r =   Res("vector", "register", "in_r1");
+       Emit(". maxps %S1, %S0");
+       Priority(2);
+
+       if(a[0] < b[0])
+               r[0] = b[0];
+       else
+               r[0] = a[0];
+
+       if(a[1] < b[1])
+               r[1] = b[1];
+       else
+               r[1] = a[1];
+
+       if(a[2] < b[2])
+               r[2] = b[2];
+       else
+               r[2] = a[2];
+
+       if(a[3] < b[3])
+               r[3] = b[3];
+       else
+               r[3] = a[3];
+}
+
+void psadbw()
+{
+       unsigned char *a = Arg_0("vector", "register", "xmm");
+       unsigned char *b = Arg_1("vector", "register", "xmm");
+       unsigned int  *r =   Res("vector", "register", "in_r1");
+       Emit(". psadbw %S1, %S0\\n. phaddd %S0, %S0\\n. phaddd %S0, %S0");
+       Priority(2);
+
+       r[0] = ((a[0] > b[0]) ? (a[0] - b[0]) : (b[0] - a[0])) +
+              ((a[1] > b[1]) ? (a[1] - b[1]) : (b[1] - a[1])) +
+              ((a[2] > b[2]) ? (a[2] - b[2]) : (b[2] - a[2])) +
+                  ((a[3] > b[3]) ? (a[3] - b[3]) : (b[3] - a[3])) +
+                  ((a[4] > b[4]) ? (a[4] - b[4]) : (b[4] - a[4])) +
+              ((a[5] > b[5]) ? (a[5] - b[5]) : (b[5] - a[5])) +
+              ((a[6] > b[6]) ? (a[6] - b[6]) : (b[6] - a[6])) +
+              ((a[7] > b[7]) ? (a[7] - b[7]) : (b[7] - a[7])) +
+              ((a[8] > b[8]) ? (a[8] - b[8]) : (b[8] - a[8])) +
+              ((a[9] > b[9]) ? (a[9] - b[9]) : (b[9] - a[9])) +
+              ((a[10] > b[10]) ? (a[10] - b[10]) : (b[10] - a[10])) +
+              ((a[11] > b[11]) ? (a[11] - b[11]) : (b[11] - a[11])) +
+              ((a[12] > b[12]) ? (a[12] - b[12]) : (b[12] - a[12])) +
+              ((a[13] > b[13]) ? (a[13] - b[13]) : (b[13] - a[13])) +
+              ((a[14] > b[14]) ? (a[14] - b[14]) : (b[14] - a[14])) +
+              ((a[15] > b[15]) ? (a[15] - b[15]) : (b[15] - a[15]));
+}
+
+/*void sadps(void)
+{
+       float *a = Arg_0("vector", "register", "xmm");
+       float *b = Arg_1("vector", "register", "xmm");
+       float *r =   Res("vector", "register", "in_r1");
+
+       r[0] = (a[0] - b[0]) + (a[1] - b[1]) + (a[2] - b[2]) + (a[3] - b[3]);
+
+
+} */
+
+
+void vstore_4f(void)
+{
+       float *param =   Arg_0("vector", "register", "xmm");
+       float *result =  Arg_1("vector", "memory", "gp");
+       Emit(". movaps %S0, (%S1)");
+       Priority(4);
+
+       result[0] = param[0];
+       result[1] = param[1];
+       result[2] = param[2];
+       result[3] = param[3];
+}
+
+
+
+#if 0
+/************************************************************************/
+/* vstore                                                               */
+/* Input:     Vector register 1 v1, memory pointer p1                   */
+/* Output:    None.                                                     */
+/* Operation: Store the components of v1 at memory location p1.         */
+/************************************************************************/
+
+void vstore_4_32(void)
+{
+       sse_32_2 *param = Arg_0("vector", "register", "xmm");
+       sse_32_2 *result = Arg_1("vector", "memory", "gp");
+       Emit(". movq %S0, (%S1)");
+       Priority(4);
+
+       result[0] = param[0];
+       result[1] = param[1];
+       result[2] = param[2];
+       result[3] = param[3];
+}
+
+
+void vstore_2_32(void)
+{
+       sse_32_2 *param = Arg_0("vector", "register", "xmm");
+       sse_32_2 *result = Arg_1("vector", "memory", "gp");
+       Emit(". movq %S0, (%S1)");
+       Priority(5);
+
+       result[0] = param[0];
+       result[1] = param[1];
+}
+
+#endif
+
+void component_0f(void)
+{
+       float *b = Arg_0("vector", "register", "xmm");
+       float *r = Res("scalar", "register", "xmm");
+       Priority(PRIORITY_CLEANUP);
+       Emit("");//. movd %S0, %D0");
+
+       *r = b[0];
+}
+
+
+
+
+void component_0Iu(void)
+{
+       int *b = Arg_0("vector", "register", "xmm");
+       int *r = Res("scalar", "register", "gp");
+       Priority(PRIORITY_CLEANUP);
+       Emit(". movd %S0, %D0");
+
+       *r = b[0];
+}
+#if 0
+void component_0(void)
+{
+       sse_32_2 *b = Arg_0("vector", "register", "xmm");
+       sse_32_2 *r = Res("scalar", "register", "gp");
+       Priority(PRIORITY_CLEANUP);
+       Emit(". movd %S0, %D0");
+
+       *r = b[0];
+}
+
+void component_1(void)
+{
+       sse_32_2 *b = Arg_0("vector", "register", "xmm");
+       sse_32_2 *r = Res("scalar", "register", "gp");
+       Destroys("in_r0");
+       Priority(PRIORITY_CLEANUP);
+       Emit(". psrldq \\$4, %S0 \\n. movd %S0, %D0");
+
+       *r = b[1];
+}
+
+void component_2(void)
+{
+       sse_32_2 *b = Arg_0("vector", "register", "xmm");
+       sse_32_2 *r = Res("scalar", "register", "gp");
+       Destroys("in_r0");
+       Priority(PRIORITY_CLEANUP);
+       Emit(". psrldq \\$8, %S0 \\n. movd %S0, %D0");
+
+       *r = b[2];
+}
+
+void component_3(void)
+{
+       sse_32_2 *b = Arg_0("vector", "register", "xmm");
+       sse_32_2 *r = Res("scalar", "register", "gp");
+       Destroys("in_r0");
+       Priority(PRIORITY_CLEANUP);
+       Emit(". psrldq \\$12, %S0 \\n. movd %S0, %D0");
+
+       *r = b[3];
+}
+
+
+/********************************
+ * THIS IS SSE3!
+ ********************************/
+
+
+void packed_add_8_32(void)
+{
+       sse_32_2 *a = Arg_0("vector", "register", "xmm");
+       sse_32_2 *b = Arg_1("vector", "register", "xmm");
+       sse_32_2 *r = Res("vector",   "register", "in_r0");
+       Priority(3);
+       Emit(". haddps %S1, %S0");
+
+       r[0] = a[0] + a[1];
+       r[1] = a[2] + b[3];
+       r[2] = b[0] + b[1];
+       r[3] = b[2] + b[3];
+}
+#endif

diff --git a/ir/be/grgen/simd/C_Patterns/Firm.gm b/ir/be/grgen/simd/C_Patterns/Firm.gm
new file mode 100644 (file)
index 0000000..8605014
--- /dev/null
+++ b/ir/be/grgen/simd/C_Patterns/Firm.gm
@@ -0,0 +1,462 @@
+/*
+ * Project:     GRS
+ * File name:   Firm.gm
+ * Purpose:     A specification of Firm for use with GrGen
+ * Author:      Rubino Geiss
+ * Mowified by:
+ * Created:     10.9.2003
+ * Copyright:   (c) 2004 Universitaet Karlsruhe
+ * Licence:     GPL
+ */
+
+model Firm;
+
+node class FIRM_node extends Node {
+       generation: int;
+}
+
+edge class FIRM_edge extends Edge {
+       generation: int;
+       pos: int;
+}
+
+/**********************************************
+ * Modes                                      *
+ **********************************************/
+
+enum ENUM_sort {
+       auxiliary, control_flow, memory, internal_boolean,
+       int_number, float_number, reference, character
+}
+enum ENUM_arithmetic_kind {
+       uninitialized, none, twos_complement, ones_complement,
+       int_BCD, ieee754, float_BCD, max, unknown
+}
+enum ENUM_modecode {
+       irm_BB, irm_X,   irm_F,   irm_D,  irm_E,  irm_Bs,
+       irm_Bu, irm_Hs,  irm_Hu,  irm_Is, irm_Iu, irm_Ls,
+       irm_Lu, irm_C,   irm_P,   irm_b,  irm_M,  irm_T,
+       irm_U,  irm_ANY, irm_BAD, irm_max
+}
+
+node class Mode extends FIRM_node {
+       name            : string;
+       size            : int;
+       sort            : ENUM_sort;
+/*     code            : ENUM_modecode; */
+       sign            : boolean;
+       arithmetic      : ENUM_arithmetic_kind;
+       shift           : int;
+}
+
+
+node class Mode_BB   extends Mode;
+node class Mode_X    extends Mode;
+node class Mode_F    extends Mode;
+node class Mode_D    extends Mode;
+node class Mode_E    extends Mode;
+node class Mode_Bs   extends Mode;
+node class Mode_Bu   extends Mode;
+node class Mode_Hs   extends Mode;
+node class Mode_Hu   extends Mode;
+node class Mode_Is   extends Mode;
+node class Mode_Iu   extends Mode;
+node class Mode_Ls   extends Mode;
+node class Mode_Lu   extends Mode;
+node class Mode_C    extends Mode;
+node class Mode_P    extends Mode;
+node class Mode_b    extends Mode;
+node class Mode_M    extends Mode;
+node class Mode_T    extends Mode;
+node class Mode_U    extends Mode;
+node class Mode_ANY  extends Mode;
+node class Mode_BAD  extends Mode;
+node class Mode_max  extends Mode;
+node class Mode_DLu  extends Mode;
+node class Mode_LLu  extends Mode;
+
+
+
+/**********************************************
+ * Types                                      *
+ **********************************************/
+
+enum ENUM_state       { layout_undefined, layout_fixed }
+
+/************* Type Nodes         *************/
+
+node class Type extends FIRM_node {
+       id    : int;
+       name  : string;
+       state : ENUM_state;
+       size  : int;
+       align : int;
+}
+
+node class Compound extends Type;
+node class Class extends Compound;
+node class Struct extends Compound;
+node class Union extends Compound;
+node class Method extends Type {
+       n_params : int;         // number of calling paramters
+       n_ress   : int;         // number of results
+       variadic : boolean;     // true: additional variadic parameters allowed
+}
+node class Array extends Type {
+       n_dimensions : int;
+}
+node class Enum extends Type;
+node class Pointer extends Type;
+node class Primitive extends Type;
+
+/************* Type Edges         *************/
+
+// Class (Sub) -> Class (Super)
+edge class is_subtype_of extends FIRM_edge
+       connect Class [*] -> Class [*];         // Subclass -> Superclass
+edge class member extends FIRM_edge
+                // Entities may or may not be an Compound member: [0:1]
+       connect Compound [*] -> Entity [0:1];
+edge class parameter extends FIRM_edge
+       connect Method [*] -> Type [*] {
+       position : int;
+}
+edge class result extends FIRM_edge
+       connect Method [*] -> Type [*] {
+       position : int;
+}
+edge class element_type extends FIRM_edge
+       connect Array [1] -> Type [*];
+edge class element_ent extends FIRM_edge
+       connect Array [1] -> Entity [*];
+
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+   TODO XXX const_code_irg is not walked by wif.do_block
+   TODO: Implement upper / lower in firm2grs.c
+   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+edge class lower extends FIRM_edge             // TODO: multidim arrays???
+       connect Array [*] -> IR_node [*] {
+       position : int;
+}
+edge class upper extends FIRM_edge
+       connect Array [*] -> IR_node [*] {
+       position : int;
+}
+
+edge class named_value extends FIRM_edge       // Enum -> Tarval
+       connect Enum [*] -> Tarval [*] {        // TODO: empty Enums [+]???
+       name : string;
+}
+edge class has_type extends FIRM_edge
+       connect Call     [1]   -> Type [*],
+               SymConst [0:1] -> Type [*],
+               Pointer  [1]   -> Type [*];
+
+
+/**********************************************
+ * Tarval                                     *
+ **********************************************/
+
+node class Tarval extends FIRM_node {
+       value : string;         //  is this aprobate
+}
+
+edge class has_mode extends FIRM_edge
+       connect Tarval    [1] -> Mode [*],
+               Pointer   [1] -> Mode [*],
+               Primitive [1] -> Mode [*],
+               Method    [1] -> Mode [*],
+               IR_node   [1] -> Mode [*],
+               Struct    [0:1]->Mode [*],
+                Enum      [1] -> Mode [*];
+edge class has_entity extends FIRM_edge
+       connect SymConst[0:1] -> Entity [*];
+
+
+/**********************************************
+ * Entities                                   *
+ **********************************************/
+
+enum ENUM_allocation   { automatic, parameter, dynamic, static }
+enum ENUM_visibility   { local, global, extern }
+enum ENUM_variability  { uninitialized, initialized, partly_constant, constant }
+enum ENUM_peculiarity  { description, inherited, existent }
+
+/************* Entity Nodes       *************/
+
+node class Entity extends FIRM_node {
+       name        : string;           // the (source) name of the entity
+       ld_name     : string;           // the linker name of the entity
+       offset      : int;
+       allocation  : ENUM_allocation;
+       visibility  : ENUM_visibility;
+       variability : ENUM_variability;
+       peculiarity : ENUM_peculiarity;
+       volatility  : boolean;
+}
+
+/************* Entity Edges       *************/
+
+edge class overwrites extends FIRM_edge
+       connect Entity -> Entity;               // TODO arity ???
+
+edge class init_node extends FIRM_edge;
+//     connect Entity -> Node (of Init);       // TODO arity ???
+
+edge class init_entity extends FIRM_edge;
+//     connect Entity -> Entity (of Init);     // TODO arity ???
+
+edge class graph extends FIRM_edge
+       connect Entity [0:1] -> Method_IRG [*];
+
+edge class type extends FIRM_edge
+       connect Entity [1] -> Type [*];
+
+
+/**********************************************
+ * Method IRG                                 *
+ **********************************************/
+
+/*
+ * Firm IRG the IR graph of a method.
+ * Pointing to Start and End nodes as well as its Entity
+ */
+node class Method_IRG extends FIRM_node {
+       main_method : boolean;  // set, if this method is the main entry point
+}
+
+edge class meth_start extends FIRM_edge
+       connect Method_IRG -> Start;
+
+edge class meth_end extends FIRM_edge
+       connect Method_IRG -> End;
+
+edge class frame_type extends FIRM_edge
+       connect Method_IRG -> Type;
+
+edge class belong_to extends FIRM_edge
+       connect Block -> Method_IRG;
+
+node class IR_node extends FIRM_node {
+       index : int; //quickfix for using vprojs
+}
+
+
+node class Ordinary;
+node class Special;
+node class Arithmetic extends Ordinary;
+node class Controlflow;
+node class Memory;
+
+node class Unary;
+node class Binary;
+node class Trinary;
+node class Nary;
+
+node class Commutative;
+node class Associative;
+
+
+/**********************************************
+ * IR Nodes                                   *
+ **********************************************/
+
+node class Complex extends IR_node;
+node class Block extends IR_node, Special;
+node class Start extends IR_node, Special;
+node class End extends IR_node, Special;
+
+node class Jmp extends IR_node, Controlflow;
+node class Cond extends IR_node, Controlflow, Ordinary;
+node class Return extends IR_node, Controlflow;
+node class Raise extends IR_node, Controlflow;
+
+node class Const extends IR_node, Ordinary {
+       value : string;                 // tarval coded as string
+}
+node class IntConst extends Const {
+  // ATTENTION:
+       // value inherited from Const is set to "<INTCONST>" and may not be used
+       intval : int;                   // tarval coded as string
+}
+
+node class SymConst extends IR_node, Ordinary {
+       kind    : int;
+       ptrinfo : string;
+}
+
+node class Sel extends IR_node, VectorBase;
+node class InstOf extends IR_node;
+node class Call extends IR_node;
+node class Add extends IR_node, Arithmetic, Binary, Commutative;
+node class Sub extends IR_node, Arithmetic, Binary;
+node class Minus extends IR_node, Arithmetic, Unary;
+node class Mul extends IR_node, Arithmetic, Binary, Commutative;
+node class Mulh extends IR_node, Arithmetic, Binary, Commutative;
+node class Quot extends IR_node, Arithmetic, Binary;
+node class DivMod extends IR_node, Arithmetic, Binary;
+node class Div extends IR_node, Arithmetic, Binary;
+node class Mod extends IR_node, Arithmetic, Binary;
+node class Abs extends IR_node, Arithmetic, Unary;
+node class And extends IR_node, Arithmetic, Binary, Commutative;
+node class Or extends IR_node, Arithmetic, Binary, Commutative;
+node class Eor extends IR_node, Arithmetic, Binary, Commutative;
+node class Not extends IR_node, Arithmetic, Unary;
+node class Cmp extends IR_node, Ordinary;
+node class Shl extends IR_node, Arithmetic, Binary;
+node class Shr extends IR_node, Arithmetic, Binary;
+node class Shrs extends IR_node, Arithmetic, Binary;
+node class Rot extends IR_node, Arithmetic, Binary;
+node class Conv extends IR_node, Ordinary;
+node class Cast extends IR_node; // TODO classify
+node class Phi extends IR_node, Ordinary;
+node class Mux extends IR_node, Trinary; // TODO classify
+
+node class MemNode extends IR_node, Memory {
+       volatility  : boolean;
+}
+
+node class Load extends MemNode;
+node class Store extends MemNode;
+
+enum ENUM_alloc_where { stack_alloc, heap_alloc }
+
+node class Alloc extends IR_node, Memory {
+       where : ENUM_alloc_where;
+}
+node class Free extends IR_node, Memory;
+node class Sync extends IR_node, Memory {
+       arity : int;
+}
+
+node class SyncArity2 extends Sync;// A sync with arity 2, that has a wrong arity attribute
+node class IgnoreCF;   // it is not important to which block this node is connected
+
+node class Proj extends IR_node, Ordinary, VectorBase {
+       proj : int;
+}
+
+// TODO classify the following IR_nodes
+node class Tuple extends IR_node;
+node class Id extends IR_node;
+node class Bad extends IR_node;
+node class NoMem extends IR_node;
+node class Confirm extends IR_node;
+node class Unknown extends IR_node;
+node class Filter extends IR_node;
+node class Break extends IR_node, Controlflow;
+node class CallBegin extends IR_node;
+node class EndReg extends IR_node;
+node class EndExcept extends IR_node, Controlflow;
+
+/**********************************************
+ * IR Intrinsic Nodes                         *
+ **********************************************/
+node class Intrinsic extends IR_node, Ordinary
+{
+       type : string;
+}
+
+node class IntrinsicGP  extends Intrinsic;     // a intrinsic with gp registers
+node class IntrinsicGP3  extends Intrinsic;    // a intrinsic with 3 gp registers
+node class IntrinsicFP  extends Intrinsic;     // a intrinsic with fp registers
+node class IntrinsicMMX extends Intrinsic;     // a intrinsic with mmx registers
+node class IntrinsicSSE extends Intrinsic;     // a intrinsic with sse registers
+
+node class Intrinsic_sse_sse_sse extends Intrinsic;    // a intrinsic
+node class Intrinsic_sse_sse extends Intrinsic;                // a intrinsic
+node class Intrinsic_sse_addr_sse extends Intrinsic;   // a intrinsic
+node class Intrinsic_addr_sse_store extends Intrinsic; // a intrinsic
+node class Intrinsic_reg_sse_sse extends Intrinsic;    // a intrinsic
+node class Intrinsic_sse_reg_sse extends Intrinsic;    // a intrinsic
+node class Intrinsic_sse_addr_store extends Intrinsic; // a intrinsic
+node class Intrinsic_addr_addr_store extends Intrinsic;        // a intrinsic
+node class Intrinsic_addr_sse extends Intrinsic;       // a intrinsic
+node class Intrinsic_addr_addr_sse extends Intrinsic;  // a intrinsic
+
+node class max extends IntrinsicGP;    // a max instruction
+node class min extends IntrinsicGP;    // a min instruction
+
+node class CMOV extends IntrinsicGP;   // a conditional move instruction
+
+node class CCopy extends IntrinsicGP;  // a conditional copy instruction
+                                       // CCopy(val0:df, val1:df, cond:bool):df
+
+
+node class Match;
+node class IntrinsicMatch extends Match{
+       name : string;
+}
+
+
+/************* IR Edges         *************/
+
+edge class flow extends FIRM_edge
+       connect IR_node [*] -> IR_node [*] {
+       position : int;
+}
+
+edge class df extends flow;            // IR_node -> IR_node, data flow
+edge class mem extends df;             // IR_node -> IR_node, memory
+edge class tuple extends df;           // Edges of Mode Tuple
+edge class cf extends flow             // control flow
+       connect IR_node [1] -> Block [*],
+                // We cannot distinguish ProjI etc from ProjXi: therefor 0
+                // ProjX form Start has 2 successors
+               Block   [*] -> Proj  [0:2];
+
+
+/**********************************************
+ * Extensions                                 *
+ **********************************************/
+
+node class Vector extends IR_node;
+
+node class V2 extends Vector;
+node class V4 extends Vector;
+
+node class pi;
+
+node class V2pi_1 extends V2, pi;
+node class V2pi_2 extends V2, pi;
+
+node class V4pi_1 extends V4, pi;
+node class V4pi_2 extends V4, pi;
+node class V4pi_3 extends V4, pi;
+node class V4pi_4 extends V4, pi;
+
+node class V2Load extends V2;
+node class V2Store extends V2;
+
+node class V2Sub extends V2;
+
+edge class match {
+       nr : int;
+}
+
+node class StartBlock;
+
+
+/******************
+ * SIMD Extension *
+ ******************/
+
+//select parts of a register (e.g. 32 bit of a 128 bit register)
+node class VProj extends IR_node, Ordinary
+{
+       proj : int;
+}
+
+// Add wich can have several operands
+node class MultipleAdd extends IR_node
+{
+       arity: int;
+}
+
+// A node which represents the base pointer of a vector
+node class VectorBase extends IR_node;
+
+// A backend node we need to copy simd -> gp register on ia32
+node class IR_Keep extends IR_node;

diff --git a/ir/be/grgen/simd/C_Patterns/define_operation.h b/ir/be/grgen/simd/C_Patterns/define_operation.h
new file mode 100644 (file)
index 0000000..a4d46fa
--- /dev/null
+++ b/ir/be/grgen/simd/C_Patterns/define_operation.h
@@ -0,0 +1,10 @@
+void *Arg_0(char *vec_or_scalar, char *memory_or_register, char *register_class);
+void *Arg_1(char *vec_or_scalar, char *memory_or_register, char *register_class);
+void *Arg_2(char *vec_or_scalar, char *memory_or_register, char *register_class);
+void *Res(char *vec_or_scalar,   char *memory_or_register, char *register_class);
+void Emit(char *emit_statement);
+void Destroys(char *destroyd_register);
+void Priority(int prio1, ...);
+void CostSavings(int prio1, ...);
+
+#define PRIORITY_CLEANUP 10000

diff --git a/ir/be/grgen/simd/be_spec_dumper.c b/ir/be/grgen/simd/be_spec_dumper.c
new file mode 100644 (file)
index 0000000..2e52e70
--- /dev/null
+++ b/ir/be/grgen/simd/be_spec_dumper.c
@@ -0,0 +1,125 @@
+/***************************************************************************
+* Program:             be_spec_dumper.c
+* Function:            Generates and dumps the specification for the ia32 backend
+*                              for each generated pattern.
+* Depends on:  Needs the analysis info generated by the pattern creator
+* Author:              Andreas Schoesser
+* Date:                        2007-03-02
+***************************************************************************/
+
+
+// ---------------------------- INCLUDES --------------------------------
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "simd_presets.h"
+
+#include "irgraph.h"
+#include "pmap.h"
+
+#include "create_pattern_t.h"
+#include "be_spec_dumper.h"
+
+
+
+
+/************************************************************************
+ * Inits the backend specification dumper
+ * Generates a new file and with a header
+ * Returns:    a be_spec_env_t structure which has to be passed to all
+ *                     spec_dumper functions
+ ************************************************************************/
+
+be_spec_env_t *init_be_spec()
+{
+       be_spec_env_t *be_spec_env = malloc(sizeof(be_spec_env_t));
+       FILE *fp = fopen(BE_SPEC_FILE, "wt");
+
+       fprintf(fp, "# This file is generated! Do not edit, your changes will be lost!\n");
+       fprintf(fp, "#  ___ _____  _____                  _                               _\n");
+       fprintf(fp, "# / ___/ ___|| ____| __   _____  ___| |_ ___  _ __   _ __   ___   __| | ___  ___\n");
+       fprintf(fp, "# \\___ \\___ \\|  _|   \\ \\ / / _ \\/ __| __/ _ \\| '__| | '_ \\ / _ \\ / _` |/ _ \\/ __|\n");
+       fprintf(fp, "#  ___) |__) | |___   \\ V /  __/ (__| || (_) | |    | | | | (_) | (_| |  __/\\__ \\\n");
+       fprintf(fp, "# |____/____/|_____|   \\_/ \\___|\\___|\\__\\___/|_|    |_| |_|\\___/ \\__,_|\\___||___/\n\n");
+
+       be_spec_env -> output_file = fp;
+       return(be_spec_env);
+}
+
+
+
+
+/************************************************************************
+ * Dumps the backend specification of a rich instruction depending
+ * on the analysis information of the pattern creator
+ ************************************************************************/
+
+void dump_be_spec(be_spec_env_t *be_spec_env, graph_ana_info_t *graph_ana_info, int uses_memory)
+{
+       argument_descr_t *arguments[MAX_SIMD_ARGUMENTS + 2];
+       pmap_entry *entry, *entry2;
+       int max_argument = -1000, i;
+       char irg_name[255];
+       int mem_slot = (uses_memory) ? 1 : 0;
+       FILE *fp = be_spec_env->output_file;
+
+       // Order the arguments according to their arg_nr
+       memset(arguments, 0, sizeof(arguments));
+       pmap_foreach(graph_ana_info->argument_nodes, entry)
+       {
+               argument_descr_t *argument = entry->value;
+
+               if(argument->arg_nr > -2)
+               {
+                       assert(argument->arg_nr + 1 < MAX_SIMD_ARGUMENTS + 1);
+                       arguments[argument->arg_nr + 1] = argument;
+                       if(argument->arg_nr + 1 > max_argument)
+                               max_argument = argument->arg_nr + 1;
+               }
+
+       }
+
+       get_rule_name(graph_ana_info, irg_name);
+       fprintf(fp, "$nodes{\"%s\"} = {\n", irg_name);
+
+       // Dump the in-register requirements
+       fprintf(fp, "  \"reg_req\"  => { \"in\" => [ ");
+       for(i = 1; i <= max_argument; i++)
+               fprintf(fp, "\"%s\", ", arguments[i]->register_class);
+       if(uses_memory)
+               fprintf(fp, "\"none\", ");
+
+       // Dump the out-register requirements
+       fprintf(fp, "], \"out\" => [ ");
+       if(arguments[0] != NULL) // The result data
+               fprintf(fp, "\"%s\", ", arguments[0]->register_class);
+       if(uses_memory)                  // The memory out
+               fprintf(fp, "\"none\", ");
+       pmap_foreach(graph_ana_info->destroyed_regs, entry2)
+       {
+               char *destroyed_reg = (char *) entry2->value;
+               fprintf(fp, "\"%s\", ", destroyed_reg);
+       }
+       fprintf(fp, "] }, \n");
+
+       // Dump the emittment
+       fprintf(fp, "  \"emit\" => \"%s\",\n", graph_ana_info->emit_statement);
+
+       fprintf(fp, "};\n\n");
+}
+
+
+
+
+/************************************************************************
+ * Frees information allocated by the backend specification dumper
+ ************************************************************************/
+
+void deinit_be_spec(be_spec_env_t *be_spec_env)
+{
+       fclose(be_spec_env->output_file);
+       free(be_spec_env);
+}

diff --git a/ir/be/grgen/simd/be_spec_dumper.h b/ir/be/grgen/simd/be_spec_dumper.h
new file mode 100644 (file)
index 0000000..810ca06
--- /dev/null
+++ b/ir/be/grgen/simd/be_spec_dumper.h
@@ -0,0 +1,23 @@
+/*************************************************************************
+* Program:  be_spec_dumper.c
+* Function: Generates and dumps the specification for the ia32 backend
+*           for each generated pattern.
+* Author:   Andreas Schoesser
+* Date:     2007-03-02
+*************************************************************************/
+
+#ifndef __BE_SPEC_DUMPER__
+#define __BE_SPEC_DUMPER__
+
+
+typedef struct                         // Holds the environment used by the backend specification dumper
+{
+       FILE *output_file;              // The file the backend specification is written to
+} be_spec_env_t;
+
+
+be_spec_env_t  *init_be_spec();
+void                   dump_be_spec(be_spec_env_t *be_spec_env, graph_ana_info_t *graph_ana_info, int uses_memorys);
+void                   deinit_be_spec(be_spec_env_t *be_spec_env);
+
+#endif

diff --git a/ir/be/grgen/simd/create_pattern.c b/ir/be/grgen/simd/create_pattern.c
new file mode 100644 (file)
index 0000000..c08a3c7
--- /dev/null
+++ b/ir/be/grgen/simd/create_pattern.c
@@ -0,0 +1,894 @@
+/***************************************************************************
+ * Program:  create_pattern.c
+ * Function: Transforms the given ir_graph into the pattern (search) graph.
+ *                     Extracts nodes to be dumped by the grgen_dumper and other
+ *                     information into a graph_ana structure.
+ * Author:   Andreas Schoesser
+ * Date:     2006-12-07
+ ***************************************************************************/
+
+#include <dos.h>
+#include <assert.h>
+#include <malloc.h>
+#include <time.h>
+#include <stdlib.h>
+
+#include "simd_presets.h"
+
+#include "obstack.h"
+#include "pmap.h"
+#include "irgmod.h"
+#include "irprog_t.h"
+#include "irdump.h"
+#include "iredges.h"
+#include "irgopt.h"
+#include "irgwalk.h"
+#include "iroptimize.h"
+#include "tv.h"
+#include "irtools.h"
+
+#include "simd_presets.h"
+#include "firm_node_ext.h"
+#include "create_pattern_t.h"
+#include "grgen_dumper.h"
+#include "be_spec_dumper.h"
+#include "normalize.h"
+#include "rule_info_dumper.h"
+
+
+
+/************************************************************************
+ * Generates pattern for one given function
+ * representing the C-specification of a complex instruction
+ ************************************************************************/
+
+void ext_grs_create_pattern() {
+       graph_ana_info_t graph_ana_info;
+       char c, grgen_commandline[1000] = "";
+       int i, variants, rule_nr = 0;
+       struct obstack obst;                                                     // General obst for objects generated during analysis
+       int last_priority = 0;
+
+       // Environments of the used modules
+       be_spec_env_t *be_spec_env;
+       grgen_dumper_env_t *grgen_dumper_env;
+       rule_info_env_t *rule_info_env;
+
+       clock_t start_time, end_time;
+
+       #ifdef DUMP_EVERYTHING
+               for(i = 0; i < get_irp_n_irgs(); i++)
+               {
+                       char filename[1000];
+                       sprintf(filename, "%s.grg", get_entity_name(get_irg_entity(irg)));
+                       dump_irgraph_complete_grgen(get_irp_irg(i), filename, 0);
+               }
+               return;
+       #endif
+
+       // Generate Header of rule pointers file
+       rule_info_env = init_rule_info_dumper(get_irp_n_irgs() * MAX_ADDRESS_VARIANTS);
+       be_spec_env = init_be_spec();
+       grgen_dumper_env = init_grgen_dumper(GRGEN_GRAPH_FILE, 0);
+
+       // Create VProj FIRM nodes etc.
+       ext_firm_nodes();
+
+       start_time = clock();
+       for(i = 0; i < get_irp_n_irgs(); i++)
+       {
+               struct pmap *nodes_to_dump = pmap_create();      // Saves all nodes that have to be dumped after analysis
+               struct pmap *register_access = pmap_create();    // Saves LOAD and STORE nodes that access registers instead of memory,
+                                                                                                                // along with their array index.
+               struct pmap *memory_access = pmap_create();      // Saves LOAD and STORE nodes that access memory along
+               struct pmap *argument_nodes = pmap_create();     // Saves nodes that deliver pointers for memory access
+
+               obstack_init(&obst);
+
+               // Init the walker_info structure, which contains data needed or filled during
+               // the analysis of the graph
+               graph_ana_info.irg = get_irp_irg(i);
+               graph_ana_info.nodes_to_dump = nodes_to_dump;
+               graph_ana_info.register_access = register_access;
+               graph_ana_info.memory_access = memory_access;
+               graph_ana_info.argument_nodes = argument_nodes;
+               graph_ana_info.destroyed_regs = pmap_create();
+               graph_ana_info.obst = &obst;
+               graph_ana_info.num_simd_arguments = 0;
+               graph_ana_info.complex_operation_block = NULL;
+               graph_ana_info.node_to_match_block = NULL;
+               graph_ana_info.emit_statement = NULL;
+               graph_ana_info.has_result = 0;
+               graph_ana_info.variant_nr = 0;
+               graph_ana_info.priority = last_priority; // Maybe the user did not specify a priority in this pattern. Use the last priority then.
+               graph_ana_info.cost_savings = 3;
+               graph_ana_info.dump_everything = 0;
+
+               printf("*** %s ***:\n", get_entity_name(get_irg_entity(graph_ana_info.irg)));
+
+               // Dump the graph before we change anything
+               dump_ir_block_graph(graph_ana_info.irg, "-pre-create-pattern");
+
+               // Normalize the Address calculation for LOADs and STOREs
+               set_irg_memory_disambiguator_options(graph_ana_info.irg, aa_opt_no_alias);
+               optimize_load_store(graph_ana_info.irg);
+               remove_critical_cf_edges(graph_ana_info.irg);
+               normalize_address_calculation(graph_ana_info.irg, 0);
+
+
+               // Dump the graph before we change anything
+               dump_ir_block_graph(graph_ana_info.irg, "-post-norm-pattern");
+
+
+               // Analyze graph
+               irg_walk_graph(graph_ana_info.irg, walk_pre, walk_post, &graph_ana_info);
+               if(graph_ana_info.emit_statement == NULL)
+                       assert(0 && "No emit statement given!");
+
+               edges_activate(graph_ana_info.irg);
+               for(variants = 0; variants < MAX_ADDRESS_VARIANTS; variants++)
+               {
+                       int uses_memory; // TODO: Maybe find the out during analysis.
+
+                       // Dump rule information
+                       dump_rule_info(rule_info_env, &graph_ana_info, graph_ana_info.num_simd_arguments);
+                       rule_nr++;
+
+                       // Dump graph (that is pattern) in grGen format
+                       uses_memory = dump_irgraph_grgen(grgen_dumper_env, &graph_ana_info);
+
+                       // Dump the backend specification
+                       dump_be_spec(be_spec_env, &graph_ana_info, uses_memory);
+
+                       // Add an address variant
+                       if(variants < MAX_ADDRESS_VARIANTS - 1)
+                       {
+                               if(!add_address_variant(&graph_ana_info))
+                                       break;
+                               graph_ana_info.variant_nr++;
+                       }
+               }
+
+               // New code placement
+               //      set_opt_global_cse(1);
+               //      optimize_graph_df(walker_info.irg);
+               //      place_code(walker_info.irg);
+               //      set_opt_global_cse(0);
+
+               // Dump graph in .vcg format
+               dump_ir_block_graph(graph_ana_info.irg, "-post-create-pattern");
+
+               //dump_type_graph (walker_info.irg, "-TYPES");
+
+               // Clean up
+               pmap_destroy(nodes_to_dump);
+               pmap_destroy(register_access);
+               pmap_destroy(argument_nodes);
+               pmap_destroy(memory_access);
+               pmap_destroy(graph_ana_info.destroyed_regs);
+
+               obstack_free(&obst, NULL);
+               obstack_finish(&obst);
+               printf("\n");
+
+               last_priority = graph_ana_info.priority;
+       }
+
+       deinit_rule_info_dumper(rule_info_env);
+       deinit_grgen_dumper(grgen_dumper_env);
+       deinit_be_spec(be_spec_env);
+       end_time = clock();
+
+       printf("*******************************\n* Pattern Creation Statistics *\n*******************************\n\n");
+
+       printf("Time elapsed:   %g s\n", ((double) (end_time - start_time)) / CLOCKS_PER_SEC);
+       printf("Rules created:  %d\n", rule_nr);
+
+       printf("\n\n ** Finished pattern creation **\n\n");
+
+       printf("Run grGen now? (Y/N) ");
+       c = getchar();
+       if(c == 'y' || c == 'Y')
+               run_grgen();
+}
+
+
+
+/************************************************************************
+ * Build a command line in order to run grgen
+ * Parameters for the GrGen call are globally set in simd_presets.h
+ ************************************************************************/
+
+static void run_grgen()
+{
+       char grgen_commandline[1000];
+
+       strcpy(grgen_commandline, "java -classpath \"");
+       strcat(grgen_commandline, GRGEN_LOCATION);
+       strcat(grgen_commandline, "grgen.jar;");
+       strcat(grgen_commandline, GRGEN_LOCATION);
+       strcat(grgen_commandline, "jars/jargs.jar;");
+       strcat(grgen_commandline, GRGEN_LOCATION);
+       strcat(grgen_commandline, "jars/antlr.jar\" de.unika.ipd.grgen.Main -n -j -i -b de.unika.ipd.grgen.be.C.SearchPlanBackend -o \"");
+       strcat(grgen_commandline, GENERATION_DEST);
+       strcat(grgen_commandline, "\" \"");
+       strcat(grgen_commandline, GRGEN_GRAPH_FILE);
+       strcat(grgen_commandline, "\"");
+
+       printf("%s\n", grgen_commandline);
+
+       // Call grGen to create C source for searching the pattern
+       system(grgen_commandline);
+}
+
+
+
+/*                                        _                         _           _
+  __ _ _ __ __ _ _ __ | |__     __ _ _ __   __ _| |_   _ ___(_)___
+ / _` | '__/ _` | '_ \| '_ \   / _` | '_ \ / _` | | | | / __| / __|
+| (_| | | | (_| | |_) | | | | | (_| | | | | (_| | | |_| \__ \ \__ \
+ \__, |_|  \__,_| .__/|_| |_|  \__,_|_| |_|\__,_|_|\__, |___/_|___/
+ |___/          |_|                                |___/               */
+
+
+
+/************************************************************************
+ * Analyze LOAD and STORE nodes, mark nodes for dumping
+ ************************************************************************/
+
+static void walk_pre(ir_node *n, void * env)
+{
+       graph_ana_info_t *graph_ana_info = (graph_ana_info_t *) env;
+       struct pmap *nodes_to_dump = graph_ana_info->nodes_to_dump;
+       struct pmap *register_access = graph_ana_info->register_access;
+       struct pmap *memory_access = graph_ana_info->memory_access;
+       struct pmap *argument_nodes = graph_ana_info->argument_nodes;
+
+       ir_graph *host_irg = graph_ana_info->irg;
+       //nodes_list_t *node_to_dump;
+
+       // **** Special case: We have a Store Node
+       if(get_irn_opcode(n) == iro_Store)
+       {
+               ir_node *call_node = NULL, *add_node = NULL, *pointer_root = NULL;
+               unsigned int array_index = 0;
+
+               call_node = search_call(n, &array_index, &add_node, &pointer_root);
+               if(is_memory_access(call_node))
+               {
+                       memory_access_descr_t *memory_access_descr = obstack_alloc(graph_ana_info->obst, sizeof(memory_access_descr_t));
+
+                       // Operations on memory vectors HAVE to access the vector index 0!
+                       if(array_index == 0)
+                               mark_argument_node(graph_ana_info, call_node, pointer_root, add_node);
+
+                       // Memory STORE, nothing has to be done
+                       memory_access_descr->load_store = MEMORY_STORE;
+                       memory_access_descr->array_index = array_index;
+                       pmap_insert(memory_access, n, (void *) memory_access_descr);
+               }
+               else
+               {
+                       register_access_descr_t *register_access_descr = obstack_alloc(graph_ana_info->obst, sizeof(register_access_descr_t));
+
+                       // Store information about the argument node
+                       mark_argument_node(graph_ana_info, call_node, pointer_root, add_node);
+
+                       // Fill the register access descriptor
+                       register_access_descr -> array_index = array_index;
+                       register_access_descr -> load_store  = REGISTER_STORE;
+                       register_access_descr -> replace_node_name = NULL;
+                       register_access_descr -> pointer_base = pointer_root;
+
+                       // Mark the predecessor of the store node as the result to be stored in a register
+                       if(get_irn_opcode(get_irn_n(n, 2)) == iro_Conv)
+                       {
+                               /* Hack */
+                               ir_node *conv = get_irn_n(n, 2);
+                               exchange(conv, get_irn_n(conv, 0));
+                       }
+
+                       pmap_insert(register_access, get_irn_n(n, 2), (void *) register_access_descr);
+
+                       // Prevent the Address of the STORE node to be dumped.
+                       set_irn_visited(get_irn_n(n, 1), get_irg_visited(get_irn_irg(n)));
+
+                       // Don't dump the STORE NODE
+                       return;
+               }
+       }
+
+
+       // **** Special case: We have a Load node
+       if(get_irn_opcode(n) == iro_Load)
+       {
+               ir_node *call_node = NULL, *add_node = NULL, *pointer_root = NULL;
+               unsigned int array_index = 0;
+
+               //      kill_mem_pred(n);
+               call_node = search_call(n, &array_index, &add_node, &pointer_root);
+
+               if(is_memory_access(call_node))
+               {
+                       memory_access_descr_t *memory_access_descr = obstack_alloc(graph_ana_info->obst, sizeof(memory_access_descr_t));
+
+                       // Operations on memory vectors HAVE to access the vector index 0!
+                       if(array_index == 0)
+                               mark_argument_node(graph_ana_info, call_node, pointer_root, add_node);
+
+                       // Memory access, nothing has to be done
+
+                       memory_access_descr->load_store = MEMORY_LOAD;
+                       memory_access_descr->array_index = array_index;
+                       pmap_insert(memory_access, n, (void *) memory_access_descr);
+               }
+               else
+               {
+                       // Register access, save information about this load
+                       register_access_descr_t *register_access_descr = obstack_alloc(graph_ana_info->obst, sizeof(register_access_descr_t));
+
+                       mark_argument_node(graph_ana_info, call_node, pointer_root, add_node);
+
+                       // Fill the register access descriptor
+                       register_access_descr->load_store  = REGISTER_LOAD;
+                       register_access_descr->array_index = array_index;
+                       register_access_descr -> replace_node_name = NULL;
+                       register_access_descr -> pointer_base = pointer_root;
+
+                       // Mark this LOAD node, which has to be exchanged by a VProj node
+                       pmap_insert(register_access, n, (void *) (register_access_descr));
+
+                       if(add_node != NULL)
+                               set_irn_visited(add_node, get_irg_visited(get_irn_irg(add_node)));
+
+                       pmap_insert(nodes_to_dump, pointer_root, NULL); // TODO: If the value is already there, will it be overwritten?
+
+                       // Don't dump this LOAD node.
+                       return;
+               }
+       }
+
+       // Mark the current node for Dumping
+       switch(get_irn_opcode(n))
+       {
+
+               case iro_Call:
+                       search_emit_statement(n, graph_ana_info);
+                       break;
+               case iro_End: //We match also the end node.
+               case iro_Start:
+               case iro_Return:
+               case iro_Block:
+               case iro_SymConst:
+               //case iro_Jmp:
+               case iro_Sync:
+               case iro_Bad:
+                       break;
+
+               case iro_Phi:
+                       if(get_irn_modecode(n) != irm_M)
+                               mark_node_for_dumping(n, graph_ana_info);
+                       break;
+
+               case iro_Proj:
+                       // Proj's beyond LOADs and STOREs will be dumped in walk-post method
+                       // to be sure that all information about the LOAD and STORE has been already computed.
+                       if(get_irn_opcode(get_irn_n(n, 0)) == iro_Load || get_irn_opcode(get_irn_n(n, 0)) == iro_Store)
+                               break;
+                       if(get_irn_opcode(get_irn_n(n, 0)) == iro_Call || get_irn_opcode(get_irn_n(n, 0)) == iro_Start)
+                               break;
+                       if(get_irn_modecode(n) == irm_X && get_irg_start_block(graph_ana_info->irg) == get_nodes_block(n)) // We don't need the initial ProjX
+                               break; // TODO: This is only valid of only one block is there!!!
+
+                       // Else Fall through
+
+               default:
+                       mark_node_for_dumping(n, graph_ana_info);
+                       break;
+       }
+}
+
+
+
+/************************************************************************
+ * Take special care of Proj nodes beyond LOAD and STORE
+ * Here we can be sure that the LOAD or STORE node has already been
+ * analyzed.
+ ************************************************************************/
+
+static void walk_post(ir_node *n, void * env)
+{
+       graph_ana_info_t *graph_ana_info = (graph_ana_info_t *) env;
+       struct pmap *nodes_to_dump = graph_ana_info->nodes_to_dump;
+       struct pmap *register_access = graph_ana_info->register_access;
+       struct pmap *memory_access = graph_ana_info->memory_access;
+       ir_graph *host_irg = graph_ana_info->irg;
+
+       if(get_irn_opcode(n) == iro_Proj)
+       {
+               ir_node *proj_pred = get_irn_n(n, 0);
+
+
+               if(get_irn_opcode(proj_pred) == iro_Store)
+               {
+                       ir_mode *store_mode = get_irn_mode(get_Store_value(proj_pred));
+
+                       if(pmap_contains(memory_access, proj_pred))
+                       {
+                               memory_access_descr_t *memory_access_descr = pmap_get(memory_access, proj_pred);
+                               memory_access_descr->projm = n;
+                               memory_access_descr->array_index /= get_mode_size_bytes(store_mode);
+
+                               printf("MEMORY STORE at array index %d\n", memory_access_descr->array_index);
+
+                               // Mark the current proj for dumping.
+                               mark_node_for_dumping(n, graph_ana_info);
+                               //pmap_insert(memory_access, n, memory_access_descr);
+                       }
+                       else
+                       {
+                               // Adapt array index
+                               register_access_descr_t *register_access_descr = pmap_get(register_access, get_Store_value(proj_pred));
+                               register_access_descr->array_index /= get_mode_size_bytes(store_mode);
+                               printf("REGISTER STORE at array index %d\n", register_access_descr->array_index);
+                               // Register STORE, don't dump it's ProjM
+                               return;
+                       }
+               }
+
+               if(get_irn_opcode(proj_pred) == iro_Load)
+               {
+                       ir_mode *load_mode = get_irn_mode(n);
+
+                       if(pmap_contains(register_access, proj_pred))
+                       {
+                               // Register LOAD: Take special care of proj's
+
+
+                               if(get_irn_modecode(n) != irm_M)
+                               {
+                                       ir_node *vproj_node;
+                                       register_access_descr_t *register_access_descr = pmap_get(register_access, proj_pred);
+                                       register_access_descr -> array_index /= get_mode_size_bytes(load_mode);
+                                       printf("REGISTER LOAD at array index %d\n", register_access_descr->array_index);
+
+                                       // We cannot use 'exchange' here, because the node n could already be in
+                                       // the register_access or memory_access list. Exchanging would result in a wrong pointer
+                                       // in those lists. Luckily Proj an VProj use the same node data, so we can just
+                                       // retype the proh to vproj without danger.
+
+                                       set_irn_n(n, 0, register_access_descr->pointer_base);
+                                       set_irn_op(n, op_VProj);
+                                       vproj_node = n;
+                                       set_VProj_proj(n, register_access_descr->array_index);
+                               }
+                               else
+                               {
+                                       // It's the memory proj. Just don't dump it
+                                       return;
+                               }
+                       }
+                       else
+                       {
+                               if(get_irn_modecode(n) != irm_M)
+                               {
+                                       memory_access_descr_t *memory_access_descr = pmap_get(memory_access, proj_pred);
+                                       memory_access_descr -> array_index /= get_mode_size_bytes(load_mode);
+                                       printf("MEMORY LOAD at array index %d\n", memory_access_descr->array_index);
+                               }
+                       }
+
+                       // Mark the current proj for dumping.
+                       mark_node_for_dumping(n, graph_ana_info);
+               }
+       }
+}
+
+void mark_node_for_dumping(ir_node *n, graph_ana_info_t *graph_ana_info)
+{
+       analyze_complex_operation_block(n, graph_ana_info);
+       pmap_insert(graph_ana_info->nodes_to_dump, n, NULL);
+       if(get_irn_opcode(n) != iro_Block && get_irn_opcode(n) != iro_Const)
+       {
+               ir_node *block = get_nodes_block(n);
+               pmap_insert(graph_ana_info->nodes_to_dump, block, NULL);
+       }
+}
+
+
+
+/************************************************************************
+ * Analyzes the behavior of a LOAD or STORE node
+ * Also detects ConvP node and prevents further dumping
+ * start_node:  LOAD or STORE node to analyze
+ * array_index: Returns the array index of the LOAD or STORE
+ * result:      CALL node defining the behavior of the LOAD OR STORE
+ ************************************************************************/
+
+static ir_node *search_call(ir_node *start_node, unsigned int *array_index, ir_node **add, ir_node **pointer_root)
+{
+       ir_node *add_node;
+       //ir_node *convP_node;  // If there's convP involved, replace proj_node by conP_node
+       ir_node *proj_node;
+       ir_node *call_node;
+       ir_node *proj_pred_node;
+       int     aindex = 0;
+
+       assert(get_irn_opcode(start_node) == iro_Load || get_irn_opcode(start_node) == iro_Store);
+
+       add_node = get_irn_n(start_node, 1);
+
+       if(get_irn_opcode(add_node) != /*iro_Add*/ iro_MultipleAdd)
+       {
+               // Add node is not there if array Index is 0
+               proj_node = add_node;
+               add_node = NULL;
+               assert(0); // Must not happen when multiple Adds are there
+       }
+       else
+       {
+               // Analyze MultipleAdd predecessors
+               if(get_irn_opcode(get_irn_n(add_node, 0)) == iro_Proj)
+               {
+                       proj_node = get_irn_n(add_node, 0);
+                       aindex = get_tarval_long(get_Const_tarval(get_irn_n(add_node, 1))); // get_mode_size_bytes(get_irn_mode()) /*4*/;  // TODO: varibale TARVALS
+               }
+               else
+               {
+                       proj_node = get_irn_n(add_node, 1);
+                       aindex = get_tarval_long(get_Const_tarval(get_irn_n(add_node, 0)));// / 4;  // TODO: varibale TARVALS
+               }
+       }
+
+       assert(get_irn_opcode(proj_node) == iro_Proj);
+       //call_node = get_irn_n(get_irn_n(get_irn_n(convP_node, 0), 0), 0); // ConvP -> ProjIs -> ProjT -> Call
+       call_node = get_irn_n(get_irn_n(proj_node, 0), 0); // ProjIs -> ProjT -> Call
+       assert(get_irn_opcode(call_node) == iro_Call && "Call node not found! Pattern not valid.");
+
+       *array_index = aindex;
+       *add = add_node;
+       *pointer_root = proj_node;
+
+       // Prevent further dumping of nodes starting from that convP Node
+       proj_pred_node = get_irn_n(proj_node, 0);
+       set_irn_visited(proj_pred_node, get_irg_visited(get_irn_irg(proj_pred_node)));
+
+       return(call_node);
+}
+
+
+
+/************************************************************************
+ * Marks a vector base pointer to be used as an argument for the
+ * complex operation afterwards
+ ************************************************************************/
+
+static void mark_argument_node(graph_ana_info_t *graph_ana_info, ir_node *call_node, ir_node *argument_node, ir_node *add_node)
+{
+       const char *arg_name;
+       int  arg_nr = -1, i;
+
+       // Look if we marked that node already
+       if(!pmap_contains(graph_ana_info->argument_nodes, argument_node))
+       {
+               // No. Find out which argument number this node will be
+               // for complex operation
+               arg_name = get_entity_name(get_SymConst_entity(get_irn_n(call_node, 1)));
+
+               // Is it the result pointer?
+               if(strcmp(arg_name, RESULT_NAME) == 0)
+               {
+                       // Arg nr is -1 since we don't know how much
+                       char *register_class;
+                       argument_descr_t *argument_descr = obstack_alloc(graph_ana_info->obst, sizeof(argument_descr_t));
+
+                       register_class = obstack_alloc(graph_ana_info->obst, get_SymConst_strlen(get_irn_n(call_node, 4)));
+                       get_SymConst_string(get_irn_n(call_node, 4), register_class);
+
+                       argument_descr -> arg_nr = -1;
+                       argument_descr -> argument_location = ARGUMENT_RESULT;                  // TODO: This is wrong, Memory or Register here
+                       argument_descr -> argument_type = (is_vector(call_node) ? ARGUMENT_VECTOR : ARGUMENT_SCALAR);
+                       argument_descr -> register_class = register_class;
+                       argument_descr -> vec_op_input = add_node; // Only important for memory access nodes
+
+                       pmap_insert(graph_ana_info->argument_nodes, argument_node, (void *) argument_descr);
+                       graph_ana_info->has_result = 1;
+                       return;
+               }
+
+               for(i = 0; i < MAX_SIMD_ARGUMENTS; i++)
+                       if(strcmp(arg_name, SIMD_ARGUMENTS[i]) == 0)
+                       {
+                               char *register_class;
+                               argument_descr_t *argument_descr = obstack_alloc(graph_ana_info->obst, sizeof(argument_descr_t));
+
+                               register_class = obstack_alloc(graph_ana_info->obst, get_SymConst_strlen(get_irn_n(call_node, 4)));
+                               get_SymConst_string(get_irn_n(call_node, 4), register_class);
+
+                               argument_descr -> arg_nr = i;
+                               argument_descr -> argument_location = (!is_memory_access(call_node) ? ARGUMENT_SIMD_REGISTER : ARGUMENT_MEMORY);
+                               argument_descr -> argument_type = (is_vector(call_node) ? ARGUMENT_VECTOR : ARGUMENT_SCALAR);
+                               argument_descr -> register_class = register_class;
+                               argument_descr -> vec_op_input = add_node;
+
+                               pmap_insert(graph_ana_info->argument_nodes, argument_node, (void *) argument_descr);
+                               graph_ana_info->num_simd_arguments = MAX(i, graph_ana_info->num_simd_arguments);
+                               break;
+                       }
+       }
+}
+
+
+
+/************************************************************************
+ * Tests, if the given call_node is the emit-statement
+ * If so, saves the emit-statement for dumping later in the process.
+ ************************************************************************/
+
+void search_emit_statement(ir_node *call_node, graph_ana_info_t *graph_ana_info)
+{
+       ir_node *symC_name;
+       ir_node *symC_arg;
+       const char *function_name;
+       int i;
+
+       assert(get_irn_opcode(call_node) == iro_Call);
+
+       // Prevent walker to consider arguments of the call node.
+       for(i = 1; i < get_irn_arity(call_node); i++)
+               set_irn_visited(get_irn_n(call_node, i), get_irg_visited(get_irn_irg(call_node)));
+
+       // Check the function name
+       symC_name = get_irn_n(call_node, 1);
+       function_name = get_entity_name(get_SymConst_entity(symC_name));
+
+       // Save the emit statement
+       if(strcmp(function_name, EMIT) == 0)
+       {
+               // Allocate space for the emit statement and save it.
+               char *emit_statement;
+               symC_arg = get_irn_n(call_node, 2);
+               emit_statement = obstack_alloc(graph_ana_info->obst, get_SymConst_strlen(symC_arg));
+               get_SymConst_string(symC_arg, emit_statement);
+               graph_ana_info->emit_statement = emit_statement;
+               return;
+       }
+
+       // Save the extra registers, the complex operation destroys
+       if(strcmp(function_name, DESTROYS) == 0)
+       {
+               char *destroy_statement;
+               symC_arg = get_irn_n(call_node, 2);
+               destroy_statement = obstack_alloc(graph_ana_info->obst, get_SymConst_strlen(symC_arg));
+
+               get_SymConst_string(symC_arg, destroy_statement);
+               pmap_insert(graph_ana_info->destroyed_regs, call_node, destroy_statement);
+       }
+
+       if(strcmp(function_name, PRIORITY) == 0)
+       {
+               ir_node *c = get_irn_n(call_node, 2);           // Get the constant argument
+               assert(get_irn_opcode(c) == iro_Const && "Something is wrong with the priority node");
+               graph_ana_info->priority = get_tarval_long(get_Const_tarval(c));
+       }
+
+       if(strcmp(function_name, COST_SAVINGS) == 0)
+       {
+               ir_node *c = get_irn_n(call_node, 2);           // Get the constant argument
+               assert(get_irn_opcode(c) == iro_Const && "Something is wrong with the CostSavings node");
+
+               graph_ana_info->cost_savings = get_tarval_long(get_Const_tarval(c));
+       }
+}
+
+
+#if 0
+
+Not needed any more
+
+/************************************************************************/
+/* Cut's of the Memory predecessor of a LOAD node                       */
+/* We don't need that node in the final pattern.                        */
+/************************************************************************/
+
+static void kill_mem_pred(ir_node *load)
+{
+       assert(get_irn_opcode(load) == iro_Load);
+
+       // TODO: Think about this. Is this really enough?
+       if(get_irn_opcode(get_irn_n(get_irn_n(load, 0), 0)) == iro_Call)
+               set_irn_visited(get_irn_n(load, 0), get_irg_visited(get_irn_irg(load)));
+}
+
+#endif
+
+
+
+/************************************************************************
+ * Returns for a given call node if the underlying LOAD or STORE access
+ * memory (1) or not (0)
+ ************************************************************************/
+static int is_memory_access(ir_node *call)
+{
+       char symC_string[255];
+       ir_node *symC;
+
+       assert(get_irn_opcode(call) == iro_Call);
+       symC = get_irn_n(call, 3);
+       assert(get_irn_opcode(symC) == iro_SymConst);
+
+       get_SymConst_string(symC, symC_string);
+       if(strstr(symC_string, MEMORY_ARRAY) != 0)
+               return(1);
+       return(0);
+}
+
+
+/************************************************************************/
+/* Returns 1 if the given argument represents a vector                  */
+/************************************************************************/
+
+static int is_vector(ir_node *call)
+{
+       char symC_string[255];
+       ir_node *symC;
+
+       assert(get_irn_opcode(call) == iro_Call);
+       symC = get_irn_n(call, 2);
+       assert(get_irn_opcode(symC) == iro_SymConst);
+       get_SymConst_string(symC, symC_string);
+       if(strstr(symC_string, "vector") != 0)
+               return(1);
+       return(0);
+}
+
+
+
+/************************************************************************
+ * Analyze, if the current pattern node is in the immediate post
+ * dominator block of the start block
+ ************************************************************************/
+
+/*
+ Der Block jedes aufgenommenen Knotens wird ueberprueft.
+ Falls dieser der direkte Nachdominator des Startblocks ist, ist das der Block, in den der komplexe Befehl soll.
+
+ Problem:
+ Wird der Block dann auch wirklich mit einem Knoten des Musters verbunden?
+ Beim Component-Fall anscheinend nicht.
+ */
+
+void analyze_complex_operation_block(ir_node *n, graph_ana_info_t *graph_ana_info)
+{
+       if(graph_ana_info->complex_operation_block == NULL && get_irn_opcode(n) != iro_Block)
+       {
+               ir_node *block = get_nodes_block(n);
+               if(block != get_irg_start_block(graph_ana_info->irg))
+               {
+                       ir_node *block_pred = get_irn_n(block, 0);
+                       if(get_irn_opcode(block_pred) != iro_Block)
+                               block_pred = get_nodes_block(block_pred);
+                       if(block_pred == get_irg_start_block(graph_ana_info->irg))
+                       {
+                               if(!pmap_contains(graph_ana_info->argument_nodes, n))
+                               {
+                                       graph_ana_info->complex_operation_block = block;
+                                       graph_ana_info->node_to_match_block = n;
+                                       //pmap_insert(walker_info->nodes_to_dump, block, NULL);
+                               }
+                       }
+               }
+       }
+}
+
+
+
+/*               _             _
+__   ____ _ _ __(_) __ _ _ __ | |_ ___
+\ \ / / _` | '__| |/ _` | '_ \| __/ __|
+ \ V / (_| | |  | | (_| | | | | |_\__ \
+  \_/ \__,_|_|  |_|\__,_|_| |_|\__|___/  */
+
+/************************************************************************
+ * Generates an address mode variant
+ * Returns 0 if no variant was generated because no address calculation
+ * is made.
+ ************************************************************************/
+
+int add_address_variant(graph_ana_info_t *graph_ana_info)
+{
+       int i;
+       struct pmap *argument_nodes = graph_ana_info->argument_nodes;
+       int found = 0;
+
+       pmap_entry *entry;
+
+       pmap_foreach(argument_nodes, entry)
+       {
+               ir_node *arg = (ir_node *) entry->key;
+               argument_descr_t *arg_descr = entry->value;
+               const ir_edge_t *edge;
+               ir_node *generic_node;
+
+               if(arg_descr -> argument_type == ARGUMENT_VECTOR && arg_descr -> argument_location == ARGUMENT_MEMORY)
+               {
+                       generic_node = new_ir_node(NULL, graph_ana_info->irg, get_nodes_block(arg), op_IrNode, mode_ANY, 0, NULL);
+                       set_irn_mode(generic_node, mode_ANY);
+                       pmap_insert(graph_ana_info->nodes_to_dump, generic_node, NULL);
+                       foreach_out_edge_kind(arg, edge, EDGE_KIND_NORMAL)
+                       {
+                               ir_node *mult_add = get_edge_src_irn(edge);
+                               int new_arity = get_irn_arity(mult_add) + 1;
+                               ir_node **new_ins = alloca(new_arity * sizeof(ir_node *));
+
+                               found = 1;
+                               assert(get_irn_opcode(mult_add) == iro_MultipleAdd);
+
+                               for(i = 0; i < get_irn_arity(mult_add); i++)
+                                       new_ins[i] = get_irn_n(mult_add, i);
+                               new_ins[i] = generic_node;
+                               set_irn_in(mult_add, new_arity, new_ins);
+                       }
+
+               }
+       }
+       return(found);
+}
+
+
+
+/*                 _
+  _ __ ___ (_)___  ___
+ | '_ ` _ \| / __|/ __|
+ | | | | | | \__ \ (__
+ |_| |_| |_|_|___/\___| */
+
+
+/************************************************************************
+ * Concatenates the rule name out of the irg name and the variant
+ * number
+ ************************************************************************/
+
+void get_rule_name(graph_ana_info_t *graph_ana_info, char *rule_name)
+{
+       ir_graph *irg = graph_ana_info->irg;
+       sprintf(rule_name, "%s_variant%d", get_entity_name(get_irg_entity(irg)), graph_ana_info->variant_nr);
+}
+
+
+
+/************************************************************************
+ * Gets the number of characters contained in a string SymConst
+ * including the trailing 0-Character
+ ************************************************************************/
+
+int get_SymConst_strlen(ir_node *symC)
+{
+       ir_entity *ent = get_SymConst_entity(symC);
+       return(get_compound_ent_n_values(ent) + 1);
+}
+
+
+
+/************************************************************************
+ * Reads the string assiciated with a sym_const and stores it in
+ * 'string'
+ ************************************************************************/
+
+void get_SymConst_string(ir_node *symC, char *string)
+{
+       ir_entity *ent = get_SymConst_entity(symC);
+       int i, n;
+
+       n = get_compound_ent_n_values(ent);
+
+       for (i = 0; i < n-1; i++) {
+               ir_node *irn;
+               int c;
+
+               irn = get_compound_ent_value(ent, i);
+               c = (int) get_tarval_long(get_Const_tarval(irn));
+               string[i] = c;
+       }
+       string[i] = 0;
+}

diff --git a/ir/be/grgen/simd/create_pattern.h b/ir/be/grgen/simd/create_pattern.h
new file mode 100644 (file)
index 0000000..1b96f2a
--- /dev/null
+++ b/ir/be/grgen/simd/create_pattern.h
@@ -0,0 +1,14 @@
+/*************************************************************************
+* Program:  create_pattern.c
+* Function: Extracts nodes to be dumped as search pattern out of the
+*                      the initial pattern
+* Author:   Andreas Schoesser
+* Date:     2006-12-07
+*************************************************************************/
+
+#ifndef CREATE_PATTERN_H
+#define CREATE_PATTERN_H
+
+void ext_grs_create_pattern();
+
+#endif

diff --git a/ir/be/grgen/simd/create_pattern_t.h b/ir/be/grgen/simd/create_pattern_t.h
new file mode 100644 (file)
index 0000000..43d4399
--- /dev/null
+++ b/ir/be/grgen/simd/create_pattern_t.h
@@ -0,0 +1,104 @@
+/*************************************************************************
+* Program:  create_pattern_t.h
+* Function: Extracts nodes to be dumped as search pattern out of the
+*                      the initial pattern
+* Author:   Andreas Schoesser
+* Date:     2006-12-07
+*************************************************************************/
+
+#ifndef CREATE_PATTERN_T_H
+#define CREATE_PATTERN_T_H
+
+#include "irgraph.h"
+
+// * This struct contains information that was collected during the pattern
+// * analysis.
+typedef struct
+{
+       ir_graph *irg;                                  // The irg that was analysed
+       struct pmap *nodes_to_dump;             // Contains all nodes which have to be dumped to create the pattern
+       struct pmap *register_access;   // Contains additional information for nodes which represent a register access
+       struct pmap *memory_access;             // Contains additional information for nodes which represent a memory access
+       struct pmap *argument_nodes;    // Contains additional information for nodes which represent an arument for the complex operatione
+       struct pmap *destroyed_regs;     // Contains an entry for each extra register a complex operation destroys (except the target register which is clear to be destroyed)
+       struct obstack *obst;                   // Memory allocated during analysis, will be killed after analysis is finished
+       int num_simd_arguments;         // Number of arguments the complex operation will have
+       ir_node *complex_operation_block, // Used to match the block the complex operation will be placed in
+                       *node_to_match_block;     // Currently, only one pattern node's block is matched
+       char *emit_statement;                   // String that describes the assembly emit statement
+       int  has_result;                // Is set to 1 if the complex operation has a result
+       int  variant_nr;
+       int  priority;
+       int  cost_savings;
+       int  dump_everything;
+} graph_ana_info_t;
+
+
+// * Additional information for nodes which represent a register access
+typedef struct
+{
+       int load_store;                         // REGISTER_STORE or REGISTER_LOAD
+       int array_index;                        // The vector component of that access
+       char *replace_node_name;        // The node name of the VProj that replaces the node that generates the result (Register STORE)
+       ir_node *pointer_base;      // Represents the complex operation in case of a register LOAD
+} register_access_descr_t;
+
+
+// * Additional information for nodes which represent a memory access
+typedef struct
+{
+       int load_store;                         // MEMORY_STORE or MEMORY_LOAD
+       int array_index;                        // The vector component of that access
+       ir_node *projm;                         // Represents the projm node in case of a memory store
+} memory_access_descr_t;
+
+
+typedef enum
+{
+       ARGUMENT_SIMD_REGISTER = 0,
+       ARGUMENT_GP_REGISTER,
+       ARGUMENT_MEMORY,
+       ARGUMENT_RESULT
+} argument_location_t;
+
+typedef enum
+{
+       ARGUMENT_SCALAR = 0,
+       ARGUMENT_VECTOR
+} argument_type_t;
+
+
+
+// * Additional information for nodes which represent an argument for the complex operation
+typedef struct
+{
+       argument_location_t argument_location;      // ARGUMENT_SIMD_REGISTER or MEMORY
+       argument_type_t     argument_type;          // VECTOR or SCALAR
+    int arg_nr;                                                                // The argument number, this node will be for the complex operation
+       char *register_class;                                       // The register class used for the backend specification
+       ir_node *vec_op_input;                      // This is important for variants:
+                                                                                               // Points to the node that computes the vector address inside a
+                                                                                               // (multi dim) array.
+} argument_descr_t;
+
+
+// Internal prototypes
+
+static ir_node *search_call(ir_node *start_node, unsigned int *array_index, ir_node **add, ir_node **pointer_root);
+static int is_memory_access(ir_node *call);
+void search_emit_statement(ir_node *call_node, graph_ana_info_t *walker_info);
+static void mark_argument_node(graph_ana_info_t *walker_info, ir_node *call_node, ir_node *argument_node, ir_node *add_node);
+void get_operation_name(const char *irg_name, char *operation_name);
+void get_firmnode_name(const char *irg_name, char *firmnode_name);
+void analyze_complex_operation_block(ir_node *n, graph_ana_info_t *walker_info);
+int get_SymConst_strlen(ir_node *symC);
+void get_SymConst_string(ir_node *symC, char *string);
+static void walk_pre(ir_node *n, void * env);
+static void walk_post(ir_node *n, void * env);
+static int is_vector(ir_node *call);
+int add_address_variant(graph_ana_info_t *walker_info);
+void get_rule_name(graph_ana_info_t *walker_info, char *rule_name);
+void mark_node_for_dumping(ir_node *n, graph_ana_info_t *walker_info);
+static void run_grgen();
+
+#endif

diff --git a/ir/be/grgen/simd/firm_node_ext.c b/ir/be/grgen/simd/firm_node_ext.c
new file mode 100644 (file)
index 0000000..042a79e
--- /dev/null
+++ b/ir/be/grgen/simd/firm_node_ext.c
@@ -0,0 +1,262 @@
+/*************************************************************************
+* Program:  firm_node_ext.c
+* Function: Provides functions to extend firm by nodes needed by the
+*           SIMD optimizer
+* Author:   Andreas Schoesser
+* Date:     2007-02-01
+*************************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include "simd_presets.h"
+
+#include "irnode.h"
+#include "irtools.h"
+#include "irmemory.h"
+
+#include "ia32/gen_ia32_regalloc_if.h"
+#include "grs/base_t.h"
+
+ir_opcode iro_VProj;
+ir_op  *op_VProj;
+
+ir_opcode iro_MultipleAdd;
+ir_op *op_MultipleAdd;
+
+ir_opcode iro_IrNode;
+ir_op *op_IrNode;
+
+ir_opcode iro_Complex;
+ir_op *op_Complex;
+
+ir_opcode iro_FakeComplex;
+ir_op *op_FakeComplex;
+
+
+ir_opcode iro_be_Keep;
+extern ir_op *op_be_Keep;
+
+
+
+/************************************************************************
+ * Initialize the pattern creation.
+ * - Creates new Firm opcodes needed by the transformation
+ ************************************************************************/
+
+void ext_firm_nodes()
+{
+       // The SIMD optimization inserts ia32 specific nodes
+       // Create the opcodes for those nodes here
+       // Reason: We need those opcodes when inserting ia32_nodes anyway.
+       ia32_register_init(NULL);
+       ia32_create_opcodes();
+       be_node_init();
+
+       iro_VProj = get_next_ir_opcode();
+       op_VProj = new_ir_op(iro_VProj, "VProj", op_pin_state_pinned, 0, oparity_unary, 0, sizeof(long), NULL);
+
+       iro_MultipleAdd = get_next_ir_opcode();
+       op_MultipleAdd = new_ir_op(iro_MultipleAdd, "MultipleAdd", op_pin_state_pinned, 0, oparity_dynamic, 0, 0, NULL);
+
+       iro_IrNode = get_next_ir_opcode();
+       op_IrNode = new_ir_op(iro_IrNode, "IR_node", op_pin_state_pinned, 0, oparity_dynamic, 0, 0, NULL);
+
+       iro_Complex = get_next_ir_opcode();
+       op_Complex = new_ir_op(iro_Complex, "Complex", op_pin_state_pinned, irop_flag_none, oparity_dynamic,  0, 0, NULL);
+
+       iro_FakeComplex = get_next_ir_opcode();
+       op_FakeComplex = new_ir_op(iro_FakeComplex, "FakeComplex", op_pin_state_pinned, irop_flag_none, oparity_dynamic,  0, 0, NULL);
+
+       iro_be_Keep = get_op_code(op_be_Keep);
+
+       // Mode LLu now exists:
+       //      mode_DLu = new_ir_vector_mode("DLu", irms_int_number, 128, 4, 0, irma_none, 128);
+}
+
+
+
+/************************************************************************
+ * Inserts a new ir_node an also updates the opcode lists of the GRS
+ ************************************************************************/
+
+ir_node *new_ir_node_with_update(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, int arity, ir_node *in[])
+{
+       ir_node *new_node = new_ir_node(db, irg, block, op, mode, arity, in);
+
+       // Update the GRS' node list
+       ext_grs_irn_private_t *pr_n = _ext_grs_get_irn_private(new_node);
+       ext_grs_irg_private_t *pr_g = _ext_grs_get_irg_private(irg);
+
+       memset(pr_n, 0, sizeof(*pr_n));
+
+       // Do we have to initialize pr_n?
+
+       lc_list_add(&pr_n->node_list, &_ext_grs_NODE_LIST(pr_g, get_op_code(op), get_mode_modecode(mode)));
+
+       // Do we have to call this?
+       // (_ext_grs_N_INSTANCES(pr_g, get_op_code(op), get_mode_modecode(mode)))++;
+
+       return(new_node);
+}
+
+
+
+
+/* __  __       _ _      _       _     _
+  |  \/  |_   _| | |_   / \   __| | __| |
+  | |\/| | | | | | __| / _ \ / _` |/ _` |
+  | |  | | |_| | | |_ / ___ \ (_| | (_| |
+  |_|  |_|\__,_|_|\__/_/   \_\__,_|\__,_| */
+
+/************************************************************************
+ * Returns 1 if the given node is a MultipleAdd operation
+ ************************************************************************/
+
+int is_MultipleAdd(ir_node *n)
+{
+       return(get_irn_opcode(n) == iro_MultipleAdd);
+}
+
+
+
+/************************************************************************
+ * Returns 1 if the 2 MultipeAdd nodes have the same base addresses
+ * but different offsets > size -> no alias
+ * 0 otherwise -> may alias
+ ************************************************************************/
+
+ir_alias_relation get_multadd_alias_relation(ir_node *n1, ir_node *n2)
+{
+#if 1
+       int i, offset_diff, same_base = 1, pos1, pos2, summands_not_equal = 0, size;
+       ir_node *const1 = NULL, *const2 = NULL, *base1 = NULL, *base2 = NULL, *ma1, *ma2;
+       ir_mode *mode1, *mode2;
+
+
+       switch(get_irn_opcode(n1))
+       {
+               case iro_Store: ma1 = get_Store_ptr(n1); mode1 = get_irn_mode(get_Store_value(n1)); break;
+               case iro_Load:  ma1 = get_Load_ptr(n1);  mode1 = get_Load_mode(n1); /*mode_F;*/ /* Hack */ break;               // TODO: Get Load mode
+               default: return(no_alias);
+       }
+
+       switch(get_irn_opcode(n2))
+       {
+               case iro_Store: ma2 = get_Store_ptr(n2); mode2 = get_irn_mode(get_Store_value(n1)); break;
+               case iro_Load:  ma2 = get_Load_ptr(n2);  mode2 = get_Load_mode(n1); /*mode_F;*/ /* Hack */ break;                // TODO: Get LOAD mode
+               default: return(no_alias);
+       }
+
+       assert(is_MultipleAdd(ma1) && is_MultipleAdd(ma2));
+
+       size = MAX(get_mode_size_bytes(mode1), get_mode_size_bytes(mode2));
+
+       // Different number of summands. Return "may alias"
+       // Rethink. If they contain different Sel's or restrict pointers
+       if(get_irn_arity(ma1) != get_irn_arity(ma2))
+               return(may_alias);
+
+       // Since MultipleAdd ins are ordered, the constant value has to be in_0 in both cases
+       const1 = get_irn_n(ma1, 0);
+       const2 = get_irn_n(ma2, 0);
+       if(!is_Const(const1) && !is_Const(const2))
+               return(may_alias);
+
+       offset_diff = abs(get_tarval_long(get_Const_tarval(const1)) - get_tarval_long(get_Const_tarval(const2)));
+
+       // Go through both in-arrays simultaneously and search for the base pointers
+       // Also check the rest of the ins for equalness
+
+       for(pos1 = 1, pos2 = 1; pos1 < get_irn_arity(ma1) && pos2 <  get_irn_arity(ma1); )
+       {
+               ir_node *n1, *n2;
+
+               if((n1 = get_irn_n(ma1, pos1)) == (n2 = get_irn_n(ma2, pos2)))
+               {
+                       pos1++;
+                       pos2++;
+                       continue;
+               }
+
+               summands_not_equal = 1;
+
+               n1 = get_irn_n(ma1, pos1);
+               n2 = get_irn_n(ma2, pos2);
+
+               // Look if we have the base pointer
+               if((get_irn_opcode(n1) == iro_Proj || get_irn_opcode(n1) == iro_Sel))
+               {
+                       assert(base1 == NULL);
+                       base1 = n1;
+                       pos1++;
+               }
+
+               if((get_irn_opcode(n2) == iro_Proj || get_irn_opcode(n2) == iro_Sel))
+               {
+                       assert(base2 == NULL);
+                       base2 = n2;
+                       pos2++;
+               }
+       }
+
+       /*if(summands_not_equal)
+               return(may_alias); */
+
+       if(base1 == NULL || base2 == NULL)
+       {
+               if(!summands_not_equal)
+               {
+                       // Summands are exaclty the same (including the base) so check the constant
+                       if(offset_diff < size)
+                               return(sure_alias);  // Offsets are overlapping
+                       return(no_alias);                // Offsets are not overlapping
+               }
+               else
+               {
+                       // Summands not the same and no (or just 1) base found. Bad luck, bail out
+                       return(may_alias);
+               }
+       }
+       else
+       {
+               // Summands are different, but 2 bases were found. check them:
+               // Alias relation depends on the alias relation of the base addresses
+               assert(base1 != NULL && base2 != NULL && "We should have found 2 bases!");
+               return(get_alias_relation(get_irn_irg(base1), base1, mode_F, base2, mode_F));
+       }
+#else
+       return(may_alias);
+#endif
+}
+
+
+
+/*__     ______            _
+  \ \   / /  _ \ _ __ ___ (_)
+   \ \ / /| |_) | '__/ _ \| |
+    \ V / |  __/| | | (_) | |
+     \_/  |_|   |_|  \___// |
+                        |__/ */
+
+/************************************************************************
+ * Gets and sets the vproj number
+ ************************************************************************/
+
+int get_VProj_proj(ir_node *node)
+{
+       int *pa = (int *) get_irn_generic_attr(node);
+       return *pa;
+}
+
+void set_VProj_proj(ir_node *node, int proj)
+{
+       int *pa = get_irn_generic_attr(node);
+       *pa = proj;
+}
+
+ir_opcode get_VProj_op()
+{
+       return(iro_VProj);
+}

diff --git a/ir/be/grgen/simd/firm_node_ext.h b/ir/be/grgen/simd/firm_node_ext.h
new file mode 100644 (file)
index 0000000..91f7fc7
--- /dev/null
+++ b/ir/be/grgen/simd/firm_node_ext.h
@@ -0,0 +1,40 @@
+/*************************************************************************
+* Program:  firm_node_ext.h
+* Function: Provides functions to extend firm by nodes needed by the
+*           SIMD optimizer
+* Author:   Andreas Schoesser
+* Date:     2007-02-01
+*************************************************************************/
+
+#ifndef __FIRM_NODE_EXT__
+#define __FIRM_NODE_EXT__
+
+#include "irnode.h"
+#include "irmemory.h"
+
+extern ir_opcode iro_VProj;
+extern          ir_op     *op_VProj;
+
+extern ir_opcode iro_MultipleAdd;
+extern          ir_op   *op_MultipleAdd;
+
+extern ir_opcode iro_IrNode;
+extern ir_op *op_IrNode;
+
+extern ir_opcode iro_Complex;
+extern ir_op *op_Complex;
+
+extern ir_opcode iro_FakeComplex;
+extern ir_op *op_FakeComplex;
+
+
+//extern ir_mode *mode_DLu;
+
+ir_node *new_ir_node_with_update(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, int arity, ir_node *in[]);
+int  get_VProj_proj(ir_node *n);
+void set_VProj_proj(ir_node *n, int proj);
+void ext_firm_nodes();
+int  is_MultipleAdd(ir_node *n);
+ir_alias_relation get_multadd_alias_relation(ir_node *n1, ir_node *n2);
+
+#endif

diff --git a/ir/be/grgen/simd/gen_patterns.c b/ir/be/grgen/simd/gen_patterns.c
new file mode 100644 (file)
index 0000000..e0be854
--- /dev/null
+++ b/ir/be/grgen/simd/gen_patterns.c
@@ -0,0 +1,3450 @@
+/* generated by grgen, don't edit */
+
+#include <assert.h>
+#include <libfirm/firm.h>
+#include <grs/grs.h>
+
+/* nodeTypeMap */
+static ir_op* grs_op_ASM_CAST;
+static ir_op* grs_op_VProj;
+static ir_op* grs_op_Abs;
+static ir_op* grs_op_Nary;
+static ir_op* grs_op_Entity;
+static ir_op* grs_op_Intrinsic_sse_addr_sse;
+static ir_op* grs_op_Ordinary;
+static ir_op* grs_op_First_right_load;
+static ir_op* grs_op_Const;
+static ir_op* grs_op_Tarval;
+static ir_op* grs_op_Primitive;
+static ir_op* grs_op_IntrinsicFP;
+static ir_op* grs_op_InstOf;
+static ir_op* grs_op_IntrinsicMMX;
+static ir_op* grs_op_Left_blocked;
+static ir_op* grs_op_Compound;
+static ir_op* grs_op_IR_node;
+static ir_op* grs_op_Non_pattern_block;
+static ir_op* grs_op_IntrinsicGP;
+static ir_op* grs_op_Trinary;
+static ir_op* grs_op_Non_output_add;
+static ir_op* grs_op_SyncArity2;
+static ir_op* grs_op_min;
+static ir_op* grs_op_End;
+static ir_op* grs_op_Binary;
+static ir_op* grs_op_CCopy;
+static ir_op* grs_op_Mulh;
+static ir_op* grs_op_ASM_node;
+static ir_op* grs_op_Free;
+static ir_op* grs_op_Intrinsic_sse_sse_sse;
+static ir_op* grs_op_Break;
+static ir_op* grs_op_G2s_complex;
+static ir_op* grs_op_Union;
+static ir_op* grs_op_Start_non_pattern;
+static ir_op* grs_op_Unary;
+static ir_op* grs_op_Mul;
+static ir_op* grs_op_IntConst;
+static ir_op* grs_op_Non_output;
+static ir_op* grs_op_Start;
+static ir_op* grs_op_IntrinsicSSE;
+static ir_op* grs_op_Create_helper;
+static ir_op* grs_op_MemNode;
+static ir_op* grs_op_Right_loads;
+static ir_op* grs_op_Left_load_helper;
+static ir_op* grs_op_Match;
+static ir_op* grs_op_EndReg;
+static ir_op* grs_op_Tuple;
+static ir_op* grs_op_New_vop;
+static ir_op* grs_op_Controlflow;
+static ir_op* grs_op_Pointer;
+static ir_op* grs_op_FIRM_node;
+static ir_op* grs_op_Marker;
+static ir_op* grs_op_Non_output_Block;
+static ir_op* grs_op_V2pi_1;
+static ir_op* grs_op_V2;
+static ir_op* grs_op_IntrinsicGP3;
+static ir_op* grs_op_Eor;
+static ir_op* grs_op_V2Load;
+static ir_op* grs_op_Special;
+static ir_op* grs_op_IntrinsicMatch;
+static ir_op* grs_op_Method;
+static ir_op* grs_op_Block;
+static ir_op* grs_op_G2s_marker;
+static ir_op* grs_op_IgnoreCF;
+static ir_op* grs_op_Id;
+static ir_op* grs_op_V2Sub;
+static ir_op* grs_op_Bad;
+static ir_op* grs_op_Call;
+static ir_op* grs_op_AnyProj;
+static ir_op* grs_op_V4pi_2;
+static ir_op* grs_op_Conv;
+static ir_op* grs_op_Sync;
+static ir_op* grs_op_Phi;
+static ir_op* grs_op_Vector;
+static ir_op* grs_op_IgnoreAttrs;
+static ir_op* grs_op_V4pi_3;
+static ir_op* grs_op_Confirm;
+static ir_op* grs_op_Shrs;
+static ir_op* grs_op_Array;
+static ir_op* grs_op_Intrinsic_sse_addr_store;
+static ir_op* grs_op_Proj;
+static ir_op* grs_op_Shr;
+static ir_op* grs_op_Intrinsic_addr_addr_sse;
+static ir_op* grs_op_Return_non_pattern;
+static ir_op* grs_op_Commutative;
+static ir_op* grs_op_IgnoreCF_Vop;
+static ir_op* grs_op_And;
+static ir_op* grs_op_Left_loads;
+static ir_op* grs_op_Or;
+static ir_op* grs_op_Type;
+static ir_op* grs_op_Alloc;
+static ir_op* grs_op_Intrinsic;
+static ir_op* grs_op_pi;
+static ir_op* grs_op_Filter;
+static ir_op* grs_op_Cmp;
+static ir_op* grs_op_Memory;
+static ir_op* grs_op_Minus;
+static ir_op* grs_op_G2s;
+static ir_op* grs_op_Node;
+static ir_op* grs_op_Not;
+static ir_op* grs_op_Add;
+static ir_op* grs_op_Enum;
+static ir_op* grs_op_Intrinsic_sse_sse;
+static ir_op* grs_op_CallBegin;
+static ir_op* grs_op_Right_load_helper;
+static ir_op* grs_op_G2s_allowed;
+static ir_op* grs_op_IgnoreCF_IR_node;
+static ir_op* grs_op_Vop;
+static ir_op* grs_op_Sub;
+static ir_op* grs_op_V4;
+static ir_op* grs_op_Intrinsic_sse_reg_sse;
+static ir_op* grs_op_Raise;
+static ir_op* grs_op_Blocked;
+static ir_op* grs_op_Jmp;
+static ir_op* grs_op_Arithmetic;
+static ir_op* grs_op_Mux;
+static ir_op* grs_op_max;
+static ir_op* grs_op_G2s_param;
+static ir_op* grs_op_DivMod;
+static ir_op* grs_op_LoadStore;
+static ir_op* grs_op_Non_replace;
+static ir_op* grs_op_Non_output_Ir_node;
+static ir_op* grs_op_Meth_entity;
+static ir_op* grs_op_Non_pattern;
+static ir_op* grs_op_Sel;
+static ir_op* grs_op_Mode_marker;
+static ir_op* grs_op_VMode;
+static ir_op* grs_op_Last_left_load;
+static ir_op* grs_op_Struct;
+static ir_op* grs_op_V4pi_1;
+static ir_op* grs_op_EndExcept;
+static ir_op* grs_op_Store;
+static ir_op* grs_op_IgnoreCF_Conv;
+static ir_op* grs_op_V4pi_4;
+static ir_op* grs_op_Load;
+static ir_op* grs_op_Right_blocked;
+static ir_op* grs_op_G2s_r128_int_4;
+static ir_op* grs_op_CMOV;
+static ir_op* grs_op_Negative;
+static ir_op* grs_op_Intrinsic_addr_sse_store;
+static ir_op* grs_op_SymConst;
+static ir_op* grs_op_Intrinsic_addr_sse;
+static ir_op* grs_op_Associative;
+static ir_op* grs_op_V2Store;
+static ir_op* grs_op_Cast;
+static ir_op* grs_op_Mod;
+static ir_op* grs_op_Unknown;
+static ir_op* grs_op_Visual_helper;
+static ir_op* grs_op_Rot;
+static ir_op* grs_op_Div;
+static ir_op* grs_op_ASM_Block;
+static ir_op* grs_op_Shl;
+static ir_op* grs_op_Cond;
+static ir_op* grs_op_V2pi_2;
+static ir_op* grs_op_Intrinsic_reg_sse_sse;
+static ir_op* grs_op_Method_IRG;
+static ir_op* grs_op_Class;
+static ir_op* grs_op_Quot;
+static ir_op* grs_op_Mode;
+static ir_op* grs_op_StartBlock;
+static ir_op* grs_op_Return;
+static ir_op* grs_op_Intrinsic_addr_addr_store;
+static ir_op* grs_op_NoMem;
+/* nodeTypeMap END */
+
+/* init node ops and modes */
+static void init() {
+  grs_op_ASM_CAST = ext_grs_lookup_op("ASM_CAST");
+  grs_op_ASM_CAST = grs_op_ASM_CAST ? grs_op_ASM_CAST : new_ir_op(get_next_ir_opcode(), "ASM_CAST", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_VProj = ext_grs_lookup_op("VProj");
+  grs_op_VProj = grs_op_VProj ? grs_op_VProj : new_ir_op(get_next_ir_opcode(), "VProj", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Abs = ext_grs_lookup_op("Abs");
+  grs_op_Abs = grs_op_Abs ? grs_op_Abs : new_ir_op(get_next_ir_opcode(), "Abs", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Nary = ext_grs_lookup_op("Nary");
+  grs_op_Nary = grs_op_Nary ? grs_op_Nary : new_ir_op(get_next_ir_opcode(), "Nary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Entity = ext_grs_lookup_op("Entity");
+  grs_op_Entity = grs_op_Entity ? grs_op_Entity : new_ir_op(get_next_ir_opcode(), "Entity", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_addr_sse = ext_grs_lookup_op("Intrinsic_sse_addr_sse");
+  grs_op_Intrinsic_sse_addr_sse = grs_op_Intrinsic_sse_addr_sse ? grs_op_Intrinsic_sse_addr_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_addr_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Ordinary = ext_grs_lookup_op("Ordinary");
+  grs_op_Ordinary = grs_op_Ordinary ? grs_op_Ordinary : new_ir_op(get_next_ir_opcode(), "Ordinary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_First_right_load = ext_grs_lookup_op("First_right_load");
+  grs_op_First_right_load = grs_op_First_right_load ? grs_op_First_right_load : new_ir_op(get_next_ir_opcode(), "First_right_load", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Const = ext_grs_lookup_op("Const");
+  grs_op_Const = grs_op_Const ? grs_op_Const : new_ir_op(get_next_ir_opcode(), "Const", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Tarval = ext_grs_lookup_op("Tarval");
+  grs_op_Tarval = grs_op_Tarval ? grs_op_Tarval : new_ir_op(get_next_ir_opcode(), "Tarval", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Primitive = ext_grs_lookup_op("Primitive");
+  grs_op_Primitive = grs_op_Primitive ? grs_op_Primitive : new_ir_op(get_next_ir_opcode(), "Primitive", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicFP = ext_grs_lookup_op("IntrinsicFP");
+  grs_op_IntrinsicFP = grs_op_IntrinsicFP ? grs_op_IntrinsicFP : new_ir_op(get_next_ir_opcode(), "IntrinsicFP", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_InstOf = ext_grs_lookup_op("InstOf");
+  grs_op_InstOf = grs_op_InstOf ? grs_op_InstOf : new_ir_op(get_next_ir_opcode(), "InstOf", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicMMX = ext_grs_lookup_op("IntrinsicMMX");
+  grs_op_IntrinsicMMX = grs_op_IntrinsicMMX ? grs_op_IntrinsicMMX : new_ir_op(get_next_ir_opcode(), "IntrinsicMMX", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Left_blocked = ext_grs_lookup_op("Left_blocked");
+  grs_op_Left_blocked = grs_op_Left_blocked ? grs_op_Left_blocked : new_ir_op(get_next_ir_opcode(), "Left_blocked", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Compound = ext_grs_lookup_op("Compound");
+  grs_op_Compound = grs_op_Compound ? grs_op_Compound : new_ir_op(get_next_ir_opcode(), "Compound", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IR_node = ext_grs_lookup_op("IR_node");
+  grs_op_IR_node = grs_op_IR_node ? grs_op_IR_node : new_ir_op(get_next_ir_opcode(), "IR_node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Non_pattern_block = ext_grs_lookup_op("Non_pattern_block");
+  grs_op_Non_pattern_block = grs_op_Non_pattern_block ? grs_op_Non_pattern_block : new_ir_op(get_next_ir_opcode(), "Non_pattern_block", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicGP = ext_grs_lookup_op("IntrinsicGP");
+  grs_op_IntrinsicGP = grs_op_IntrinsicGP ? grs_op_IntrinsicGP : new_ir_op(get_next_ir_opcode(), "IntrinsicGP", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Trinary = ext_grs_lookup_op("Trinary");
+  grs_op_Trinary = grs_op_Trinary ? grs_op_Trinary : new_ir_op(get_next_ir_opcode(), "Trinary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Non_output_add = ext_grs_lookup_op("Non_output_add");
+  grs_op_Non_output_add = grs_op_Non_output_add ? grs_op_Non_output_add : new_ir_op(get_next_ir_opcode(), "Non_output_add", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_SyncArity2 = ext_grs_lookup_op("SyncArity2");
+  grs_op_SyncArity2 = grs_op_SyncArity2 ? grs_op_SyncArity2 : new_ir_op(get_next_ir_opcode(), "SyncArity2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_min = ext_grs_lookup_op("min");
+  grs_op_min = grs_op_min ? grs_op_min : new_ir_op(get_next_ir_opcode(), "min", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_End = ext_grs_lookup_op("End");
+  grs_op_End = grs_op_End ? grs_op_End : new_ir_op(get_next_ir_opcode(), "End", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Binary = ext_grs_lookup_op("Binary");
+  grs_op_Binary = grs_op_Binary ? grs_op_Binary : new_ir_op(get_next_ir_opcode(), "Binary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_CCopy = ext_grs_lookup_op("CCopy");
+  grs_op_CCopy = grs_op_CCopy ? grs_op_CCopy : new_ir_op(get_next_ir_opcode(), "CCopy", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mulh = ext_grs_lookup_op("Mulh");
+  grs_op_Mulh = grs_op_Mulh ? grs_op_Mulh : new_ir_op(get_next_ir_opcode(), "Mulh", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_ASM_node = ext_grs_lookup_op("ASM_node");
+  grs_op_ASM_node = grs_op_ASM_node ? grs_op_ASM_node : new_ir_op(get_next_ir_opcode(), "ASM_node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Free = ext_grs_lookup_op("Free");
+  grs_op_Free = grs_op_Free ? grs_op_Free : new_ir_op(get_next_ir_opcode(), "Free", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_sse_sse = ext_grs_lookup_op("Intrinsic_sse_sse_sse");
+  grs_op_Intrinsic_sse_sse_sse = grs_op_Intrinsic_sse_sse_sse ? grs_op_Intrinsic_sse_sse_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_sse_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Break = ext_grs_lookup_op("Break");
+  grs_op_Break = grs_op_Break ? grs_op_Break : new_ir_op(get_next_ir_opcode(), "Break", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_G2s_complex = ext_grs_lookup_op("G2s_complex");
+  grs_op_G2s_complex = grs_op_G2s_complex ? grs_op_G2s_complex : new_ir_op(get_next_ir_opcode(), "G2s_complex", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Union = ext_grs_lookup_op("Union");
+  grs_op_Union = grs_op_Union ? grs_op_Union : new_ir_op(get_next_ir_opcode(), "Union", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Start_non_pattern = ext_grs_lookup_op("Start_non_pattern");
+  grs_op_Start_non_pattern = grs_op_Start_non_pattern ? grs_op_Start_non_pattern : new_ir_op(get_next_ir_opcode(), "Start_non_pattern", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Unary = ext_grs_lookup_op("Unary");
+  grs_op_Unary = grs_op_Unary ? grs_op_Unary : new_ir_op(get_next_ir_opcode(), "Unary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mul = ext_grs_lookup_op("Mul");
+  grs_op_Mul = grs_op_Mul ? grs_op_Mul : new_ir_op(get_next_ir_opcode(), "Mul", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntConst = ext_grs_lookup_op("IntConst");
+  grs_op_IntConst = grs_op_IntConst ? grs_op_IntConst : new_ir_op(get_next_ir_opcode(), "IntConst", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Non_output = ext_grs_lookup_op("Non_output");
+  grs_op_Non_output = grs_op_Non_output ? grs_op_Non_output : new_ir_op(get_next_ir_opcode(), "Non_output", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Start = ext_grs_lookup_op("Start");
+  grs_op_Start = grs_op_Start ? grs_op_Start : new_ir_op(get_next_ir_opcode(), "Start", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicSSE = ext_grs_lookup_op("IntrinsicSSE");
+  grs_op_IntrinsicSSE = grs_op_IntrinsicSSE ? grs_op_IntrinsicSSE : new_ir_op(get_next_ir_opcode(), "IntrinsicSSE", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Create_helper = ext_grs_lookup_op("Create_helper");
+  grs_op_Create_helper = grs_op_Create_helper ? grs_op_Create_helper : new_ir_op(get_next_ir_opcode(), "Create_helper", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_MemNode = ext_grs_lookup_op("MemNode");
+  grs_op_MemNode = grs_op_MemNode ? grs_op_MemNode : new_ir_op(get_next_ir_opcode(), "MemNode", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Right_loads = ext_grs_lookup_op("Right_loads");
+  grs_op_Right_loads = grs_op_Right_loads ? grs_op_Right_loads : new_ir_op(get_next_ir_opcode(), "Right_loads", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Left_load_helper = ext_grs_lookup_op("Left_load_helper");
+  grs_op_Left_load_helper = grs_op_Left_load_helper ? grs_op_Left_load_helper : new_ir_op(get_next_ir_opcode(), "Left_load_helper", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Match = ext_grs_lookup_op("Match");
+  grs_op_Match = grs_op_Match ? grs_op_Match : new_ir_op(get_next_ir_opcode(), "Match", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_EndReg = ext_grs_lookup_op("EndReg");
+  grs_op_EndReg = grs_op_EndReg ? grs_op_EndReg : new_ir_op(get_next_ir_opcode(), "EndReg", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Tuple = ext_grs_lookup_op("Tuple");
+  grs_op_Tuple = grs_op_Tuple ? grs_op_Tuple : new_ir_op(get_next_ir_opcode(), "Tuple", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_New_vop = ext_grs_lookup_op("New_vop");
+  grs_op_New_vop = grs_op_New_vop ? grs_op_New_vop : new_ir_op(get_next_ir_opcode(), "New_vop", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Controlflow = ext_grs_lookup_op("Controlflow");
+  grs_op_Controlflow = grs_op_Controlflow ? grs_op_Controlflow : new_ir_op(get_next_ir_opcode(), "Controlflow", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Pointer = ext_grs_lookup_op("Pointer");
+  grs_op_Pointer = grs_op_Pointer ? grs_op_Pointer : new_ir_op(get_next_ir_opcode(), "Pointer", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_FIRM_node = ext_grs_lookup_op("FIRM_node");
+  grs_op_FIRM_node = grs_op_FIRM_node ? grs_op_FIRM_node : new_ir_op(get_next_ir_opcode(), "FIRM_node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Marker = ext_grs_lookup_op("Marker");
+  grs_op_Marker = grs_op_Marker ? grs_op_Marker : new_ir_op(get_next_ir_opcode(), "Marker", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Non_output_Block = ext_grs_lookup_op("Non_output_Block");
+  grs_op_Non_output_Block = grs_op_Non_output_Block ? grs_op_Non_output_Block : new_ir_op(get_next_ir_opcode(), "Non_output_Block", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2pi_1 = ext_grs_lookup_op("V2pi_1");
+  grs_op_V2pi_1 = grs_op_V2pi_1 ? grs_op_V2pi_1 : new_ir_op(get_next_ir_opcode(), "V2pi_1", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2 = ext_grs_lookup_op("V2");
+  grs_op_V2 = grs_op_V2 ? grs_op_V2 : new_ir_op(get_next_ir_opcode(), "V2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicGP3 = ext_grs_lookup_op("IntrinsicGP3");
+  grs_op_IntrinsicGP3 = grs_op_IntrinsicGP3 ? grs_op_IntrinsicGP3 : new_ir_op(get_next_ir_opcode(), "IntrinsicGP3", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Eor = ext_grs_lookup_op("Eor");
+  grs_op_Eor = grs_op_Eor ? grs_op_Eor : new_ir_op(get_next_ir_opcode(), "Eor", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2Load = ext_grs_lookup_op("V2Load");
+  grs_op_V2Load = grs_op_V2Load ? grs_op_V2Load : new_ir_op(get_next_ir_opcode(), "V2Load", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Special = ext_grs_lookup_op("Special");
+  grs_op_Special = grs_op_Special ? grs_op_Special : new_ir_op(get_next_ir_opcode(), "Special", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicMatch = ext_grs_lookup_op("IntrinsicMatch");
+  grs_op_IntrinsicMatch = grs_op_IntrinsicMatch ? grs_op_IntrinsicMatch : new_ir_op(get_next_ir_opcode(), "IntrinsicMatch", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Method = ext_grs_lookup_op("Method");
+  grs_op_Method = grs_op_Method ? grs_op_Method : new_ir_op(get_next_ir_opcode(), "Method", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Block = ext_grs_lookup_op("Block");
+  grs_op_Block = grs_op_Block ? grs_op_Block : new_ir_op(get_next_ir_opcode(), "Block", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_G2s_marker = ext_grs_lookup_op("G2s_marker");
+  grs_op_G2s_marker = grs_op_G2s_marker ? grs_op_G2s_marker : new_ir_op(get_next_ir_opcode(), "G2s_marker", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IgnoreCF = ext_grs_lookup_op("IgnoreCF");
+  grs_op_IgnoreCF = grs_op_IgnoreCF ? grs_op_IgnoreCF : new_ir_op(get_next_ir_opcode(), "IgnoreCF", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Id = ext_grs_lookup_op("Id");
+  grs_op_Id = grs_op_Id ? grs_op_Id : new_ir_op(get_next_ir_opcode(), "Id", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2Sub = ext_grs_lookup_op("V2Sub");
+  grs_op_V2Sub = grs_op_V2Sub ? grs_op_V2Sub : new_ir_op(get_next_ir_opcode(), "V2Sub", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Bad = ext_grs_lookup_op("Bad");
+  grs_op_Bad = grs_op_Bad ? grs_op_Bad : new_ir_op(get_next_ir_opcode(), "Bad", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Call = ext_grs_lookup_op("Call");
+  grs_op_Call = grs_op_Call ? grs_op_Call : new_ir_op(get_next_ir_opcode(), "Call", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_AnyProj = ext_grs_lookup_op("AnyProj");
+  grs_op_AnyProj = grs_op_AnyProj ? grs_op_AnyProj : new_ir_op(get_next_ir_opcode(), "AnyProj", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_2 = ext_grs_lookup_op("V4pi_2");
+  grs_op_V4pi_2 = grs_op_V4pi_2 ? grs_op_V4pi_2 : new_ir_op(get_next_ir_opcode(), "V4pi_2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Conv = ext_grs_lookup_op("Conv");
+  grs_op_Conv = grs_op_Conv ? grs_op_Conv : new_ir_op(get_next_ir_opcode(), "Conv", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Sync = ext_grs_lookup_op("Sync");
+  grs_op_Sync = grs_op_Sync ? grs_op_Sync : new_ir_op(get_next_ir_opcode(), "Sync", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Phi = ext_grs_lookup_op("Phi");
+  grs_op_Phi = grs_op_Phi ? grs_op_Phi : new_ir_op(get_next_ir_opcode(), "Phi", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Vector = ext_grs_lookup_op("Vector");
+  grs_op_Vector = grs_op_Vector ? grs_op_Vector : new_ir_op(get_next_ir_opcode(), "Vector", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IgnoreAttrs = ext_grs_lookup_op("IgnoreAttrs");
+  grs_op_IgnoreAttrs = grs_op_IgnoreAttrs ? grs_op_IgnoreAttrs : new_ir_op(get_next_ir_opcode(), "IgnoreAttrs", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_3 = ext_grs_lookup_op("V4pi_3");
+  grs_op_V4pi_3 = grs_op_V4pi_3 ? grs_op_V4pi_3 : new_ir_op(get_next_ir_opcode(), "V4pi_3", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Confirm = ext_grs_lookup_op("Confirm");
+  grs_op_Confirm = grs_op_Confirm ? grs_op_Confirm : new_ir_op(get_next_ir_opcode(), "Confirm", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Shrs = ext_grs_lookup_op("Shrs");
+  grs_op_Shrs = grs_op_Shrs ? grs_op_Shrs : new_ir_op(get_next_ir_opcode(), "Shrs", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Array = ext_grs_lookup_op("Array");
+  grs_op_Array = grs_op_Array ? grs_op_Array : new_ir_op(get_next_ir_opcode(), "Array", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_addr_store = ext_grs_lookup_op("Intrinsic_sse_addr_store");
+  grs_op_Intrinsic_sse_addr_store = grs_op_Intrinsic_sse_addr_store ? grs_op_Intrinsic_sse_addr_store : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_addr_store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Proj = ext_grs_lookup_op("Proj");
+  grs_op_Proj = grs_op_Proj ? grs_op_Proj : new_ir_op(get_next_ir_opcode(), "Proj", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Shr = ext_grs_lookup_op("Shr");
+  grs_op_Shr = grs_op_Shr ? grs_op_Shr : new_ir_op(get_next_ir_opcode(), "Shr", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_addr_addr_sse = ext_grs_lookup_op("Intrinsic_addr_addr_sse");
+  grs_op_Intrinsic_addr_addr_sse = grs_op_Intrinsic_addr_addr_sse ? grs_op_Intrinsic_addr_addr_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_addr_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Return_non_pattern = ext_grs_lookup_op("Return_non_pattern");
+  grs_op_Return_non_pattern = grs_op_Return_non_pattern ? grs_op_Return_non_pattern : new_ir_op(get_next_ir_opcode(), "Return_non_pattern", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Commutative = ext_grs_lookup_op("Commutative");
+  grs_op_Commutative = grs_op_Commutative ? grs_op_Commutative : new_ir_op(get_next_ir_opcode(), "Commutative", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IgnoreCF_Vop = ext_grs_lookup_op("IgnoreCF_Vop");
+  grs_op_IgnoreCF_Vop = grs_op_IgnoreCF_Vop ? grs_op_IgnoreCF_Vop : new_ir_op(get_next_ir_opcode(), "IgnoreCF_Vop", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_And = ext_grs_lookup_op("And");
+  grs_op_And = grs_op_And ? grs_op_And : new_ir_op(get_next_ir_opcode(), "And", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Left_loads = ext_grs_lookup_op("Left_loads");
+  grs_op_Left_loads = grs_op_Left_loads ? grs_op_Left_loads : new_ir_op(get_next_ir_opcode(), "Left_loads", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Or = ext_grs_lookup_op("Or");
+  grs_op_Or = grs_op_Or ? grs_op_Or : new_ir_op(get_next_ir_opcode(), "Or", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Type = ext_grs_lookup_op("Type");
+  grs_op_Type = grs_op_Type ? grs_op_Type : new_ir_op(get_next_ir_opcode(), "Type", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Alloc = ext_grs_lookup_op("Alloc");
+  grs_op_Alloc = grs_op_Alloc ? grs_op_Alloc : new_ir_op(get_next_ir_opcode(), "Alloc", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic = ext_grs_lookup_op("Intrinsic");
+  grs_op_Intrinsic = grs_op_Intrinsic ? grs_op_Intrinsic : new_ir_op(get_next_ir_opcode(), "Intrinsic", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_pi = ext_grs_lookup_op("pi");
+  grs_op_pi = grs_op_pi ? grs_op_pi : new_ir_op(get_next_ir_opcode(), "pi", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Filter = ext_grs_lookup_op("Filter");
+  grs_op_Filter = grs_op_Filter ? grs_op_Filter : new_ir_op(get_next_ir_opcode(), "Filter", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Cmp = ext_grs_lookup_op("Cmp");
+  grs_op_Cmp = grs_op_Cmp ? grs_op_Cmp : new_ir_op(get_next_ir_opcode(), "Cmp", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Memory = ext_grs_lookup_op("Memory");
+  grs_op_Memory = grs_op_Memory ? grs_op_Memory : new_ir_op(get_next_ir_opcode(), "Memory", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Minus = ext_grs_lookup_op("Minus");
+  grs_op_Minus = grs_op_Minus ? grs_op_Minus : new_ir_op(get_next_ir_opcode(), "Minus", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_G2s = ext_grs_lookup_op("G2s");
+  grs_op_G2s = grs_op_G2s ? grs_op_G2s : new_ir_op(get_next_ir_opcode(), "G2s", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Node = ext_grs_lookup_op("Node");
+  grs_op_Node = grs_op_Node ? grs_op_Node : new_ir_op(get_next_ir_opcode(), "Node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Not = ext_grs_lookup_op("Not");
+  grs_op_Not = grs_op_Not ? grs_op_Not : new_ir_op(get_next_ir_opcode(), "Not", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Add = ext_grs_lookup_op("Add");
+  grs_op_Add = grs_op_Add ? grs_op_Add : new_ir_op(get_next_ir_opcode(), "Add", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Enum = ext_grs_lookup_op("Enum");
+  grs_op_Enum = grs_op_Enum ? grs_op_Enum : new_ir_op(get_next_ir_opcode(), "Enum", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_sse = ext_grs_lookup_op("Intrinsic_sse_sse");
+  grs_op_Intrinsic_sse_sse = grs_op_Intrinsic_sse_sse ? grs_op_Intrinsic_sse_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_CallBegin = ext_grs_lookup_op("CallBegin");
+  grs_op_CallBegin = grs_op_CallBegin ? grs_op_CallBegin : new_ir_op(get_next_ir_opcode(), "CallBegin", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Right_load_helper = ext_grs_lookup_op("Right_load_helper");
+  grs_op_Right_load_helper = grs_op_Right_load_helper ? grs_op_Right_load_helper : new_ir_op(get_next_ir_opcode(), "Right_load_helper", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_G2s_allowed = ext_grs_lookup_op("G2s_allowed");
+  grs_op_G2s_allowed = grs_op_G2s_allowed ? grs_op_G2s_allowed : new_ir_op(get_next_ir_opcode(), "G2s_allowed", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IgnoreCF_IR_node = ext_grs_lookup_op("IgnoreCF_IR_node");
+  grs_op_IgnoreCF_IR_node = grs_op_IgnoreCF_IR_node ? grs_op_IgnoreCF_IR_node : new_ir_op(get_next_ir_opcode(), "IgnoreCF_IR_node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Vop = ext_grs_lookup_op("Vop");
+  grs_op_Vop = grs_op_Vop ? grs_op_Vop : new_ir_op(get_next_ir_opcode(), "Vop", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Sub = ext_grs_lookup_op("Sub");
+  grs_op_Sub = grs_op_Sub ? grs_op_Sub : new_ir_op(get_next_ir_opcode(), "Sub", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4 = ext_grs_lookup_op("V4");
+  grs_op_V4 = grs_op_V4 ? grs_op_V4 : new_ir_op(get_next_ir_opcode(), "V4", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_reg_sse = ext_grs_lookup_op("Intrinsic_sse_reg_sse");
+  grs_op_Intrinsic_sse_reg_sse = grs_op_Intrinsic_sse_reg_sse ? grs_op_Intrinsic_sse_reg_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_reg_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Raise = ext_grs_lookup_op("Raise");
+  grs_op_Raise = grs_op_Raise ? grs_op_Raise : new_ir_op(get_next_ir_opcode(), "Raise", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Blocked = ext_grs_lookup_op("Blocked");
+  grs_op_Blocked = grs_op_Blocked ? grs_op_Blocked : new_ir_op(get_next_ir_opcode(), "Blocked", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Jmp = ext_grs_lookup_op("Jmp");
+  grs_op_Jmp = grs_op_Jmp ? grs_op_Jmp : new_ir_op(get_next_ir_opcode(), "Jmp", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Arithmetic = ext_grs_lookup_op("Arithmetic");
+  grs_op_Arithmetic = grs_op_Arithmetic ? grs_op_Arithmetic : new_ir_op(get_next_ir_opcode(), "Arithmetic", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mux = ext_grs_lookup_op("Mux");
+  grs_op_Mux = grs_op_Mux ? grs_op_Mux : new_ir_op(get_next_ir_opcode(), "Mux", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_max = ext_grs_lookup_op("max");
+  grs_op_max = grs_op_max ? grs_op_max : new_ir_op(get_next_ir_opcode(), "max", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_G2s_param = ext_grs_lookup_op("G2s_param");
+  grs_op_G2s_param = grs_op_G2s_param ? grs_op_G2s_param : new_ir_op(get_next_ir_opcode(), "G2s_param", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_DivMod = ext_grs_lookup_op("DivMod");
+  grs_op_DivMod = grs_op_DivMod ? grs_op_DivMod : new_ir_op(get_next_ir_opcode(), "DivMod", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_LoadStore = ext_grs_lookup_op("LoadStore");
+  grs_op_LoadStore = grs_op_LoadStore ? grs_op_LoadStore : new_ir_op(get_next_ir_opcode(), "LoadStore", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Non_replace = ext_grs_lookup_op("Non_replace");
+  grs_op_Non_replace = grs_op_Non_replace ? grs_op_Non_replace : new_ir_op(get_next_ir_opcode(), "Non_replace", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Non_output_Ir_node = ext_grs_lookup_op("Non_output_Ir_node");
+  grs_op_Non_output_Ir_node = grs_op_Non_output_Ir_node ? grs_op_Non_output_Ir_node : new_ir_op(get_next_ir_opcode(), "Non_output_Ir_node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Meth_entity = ext_grs_lookup_op("Meth_entity");
+  grs_op_Meth_entity = grs_op_Meth_entity ? grs_op_Meth_entity : new_ir_op(get_next_ir_opcode(), "Meth_entity", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Non_pattern = ext_grs_lookup_op("Non_pattern");
+  grs_op_Non_pattern = grs_op_Non_pattern ? grs_op_Non_pattern : new_ir_op(get_next_ir_opcode(), "Non_pattern", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Sel = ext_grs_lookup_op("Sel");
+  grs_op_Sel = grs_op_Sel ? grs_op_Sel : new_ir_op(get_next_ir_opcode(), "Sel", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mode_marker = ext_grs_lookup_op("Mode_marker");
+  grs_op_Mode_marker = grs_op_Mode_marker ? grs_op_Mode_marker : new_ir_op(get_next_ir_opcode(), "Mode_marker", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_VMode = ext_grs_lookup_op("VMode");
+  grs_op_VMode = grs_op_VMode ? grs_op_VMode : new_ir_op(get_next_ir_opcode(), "VMode", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Last_left_load = ext_grs_lookup_op("Last_left_load");
+  grs_op_Last_left_load = grs_op_Last_left_load ? grs_op_Last_left_load : new_ir_op(get_next_ir_opcode(), "Last_left_load", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Struct = ext_grs_lookup_op("Struct");
+  grs_op_Struct = grs_op_Struct ? grs_op_Struct : new_ir_op(get_next_ir_opcode(), "Struct", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_1 = ext_grs_lookup_op("V4pi_1");
+  grs_op_V4pi_1 = grs_op_V4pi_1 ? grs_op_V4pi_1 : new_ir_op(get_next_ir_opcode(), "V4pi_1", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_EndExcept = ext_grs_lookup_op("EndExcept");
+  grs_op_EndExcept = grs_op_EndExcept ? grs_op_EndExcept : new_ir_op(get_next_ir_opcode(), "EndExcept", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Store = ext_grs_lookup_op("Store");
+  grs_op_Store = grs_op_Store ? grs_op_Store : new_ir_op(get_next_ir_opcode(), "Store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IgnoreCF_Conv = ext_grs_lookup_op("IgnoreCF_Conv");
+  grs_op_IgnoreCF_Conv = grs_op_IgnoreCF_Conv ? grs_op_IgnoreCF_Conv : new_ir_op(get_next_ir_opcode(), "IgnoreCF_Conv", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_4 = ext_grs_lookup_op("V4pi_4");
+  grs_op_V4pi_4 = grs_op_V4pi_4 ? grs_op_V4pi_4 : new_ir_op(get_next_ir_opcode(), "V4pi_4", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Load = ext_grs_lookup_op("Load");
+  grs_op_Load = grs_op_Load ? grs_op_Load : new_ir_op(get_next_ir_opcode(), "Load", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Right_blocked = ext_grs_lookup_op("Right_blocked");
+  grs_op_Right_blocked = grs_op_Right_blocked ? grs_op_Right_blocked : new_ir_op(get_next_ir_opcode(), "Right_blocked", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_G2s_r128_int_4 = ext_grs_lookup_op("G2s_r128_int_4");
+  grs_op_G2s_r128_int_4 = grs_op_G2s_r128_int_4 ? grs_op_G2s_r128_int_4 : new_ir_op(get_next_ir_opcode(), "G2s_r128_int_4", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_CMOV = ext_grs_lookup_op("CMOV");
+  grs_op_CMOV = grs_op_CMOV ? grs_op_CMOV : new_ir_op(get_next_ir_opcode(), "CMOV", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Negative = ext_grs_lookup_op("Negative");
+  grs_op_Negative = grs_op_Negative ? grs_op_Negative : new_ir_op(get_next_ir_opcode(), "Negative", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_addr_sse_store = ext_grs_lookup_op("Intrinsic_addr_sse_store");
+  grs_op_Intrinsic_addr_sse_store = grs_op_Intrinsic_addr_sse_store ? grs_op_Intrinsic_addr_sse_store : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_sse_store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_SymConst = ext_grs_lookup_op("SymConst");
+  grs_op_SymConst = grs_op_SymConst ? grs_op_SymConst : new_ir_op(get_next_ir_opcode(), "SymConst", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_addr_sse = ext_grs_lookup_op("Intrinsic_addr_sse");
+  grs_op_Intrinsic_addr_sse = grs_op_Intrinsic_addr_sse ? grs_op_Intrinsic_addr_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Associative = ext_grs_lookup_op("Associative");
+  grs_op_Associative = grs_op_Associative ? grs_op_Associative : new_ir_op(get_next_ir_opcode(), "Associative", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2Store = ext_grs_lookup_op("V2Store");
+  grs_op_V2Store = grs_op_V2Store ? grs_op_V2Store : new_ir_op(get_next_ir_opcode(), "V2Store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Cast = ext_grs_lookup_op("Cast");
+  grs_op_Cast = grs_op_Cast ? grs_op_Cast : new_ir_op(get_next_ir_opcode(), "Cast", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mod = ext_grs_lookup_op("Mod");
+  grs_op_Mod = grs_op_Mod ? grs_op_Mod : new_ir_op(get_next_ir_opcode(), "Mod", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Unknown = ext_grs_lookup_op("Unknown");
+  grs_op_Unknown = grs_op_Unknown ? grs_op_Unknown : new_ir_op(get_next_ir_opcode(), "Unknown", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Visual_helper = ext_grs_lookup_op("Visual_helper");
+  grs_op_Visual_helper = grs_op_Visual_helper ? grs_op_Visual_helper : new_ir_op(get_next_ir_opcode(), "Visual_helper", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Rot = ext_grs_lookup_op("Rot");
+  grs_op_Rot = grs_op_Rot ? grs_op_Rot : new_ir_op(get_next_ir_opcode(), "Rot", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Div = ext_grs_lookup_op("Div");
+  grs_op_Div = grs_op_Div ? grs_op_Div : new_ir_op(get_next_ir_opcode(), "Div", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_ASM_Block = ext_grs_lookup_op("ASM_Block");
+  grs_op_ASM_Block = grs_op_ASM_Block ? grs_op_ASM_Block : new_ir_op(get_next_ir_opcode(), "ASM_Block", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Shl = ext_grs_lookup_op("Shl");
+  grs_op_Shl = grs_op_Shl ? grs_op_Shl : new_ir_op(get_next_ir_opcode(), "Shl", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Cond = ext_grs_lookup_op("Cond");
+  grs_op_Cond = grs_op_Cond ? grs_op_Cond : new_ir_op(get_next_ir_opcode(), "Cond", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2pi_2 = ext_grs_lookup_op("V2pi_2");
+  grs_op_V2pi_2 = grs_op_V2pi_2 ? grs_op_V2pi_2 : new_ir_op(get_next_ir_opcode(), "V2pi_2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_reg_sse_sse = ext_grs_lookup_op("Intrinsic_reg_sse_sse");
+  grs_op_Intrinsic_reg_sse_sse = grs_op_Intrinsic_reg_sse_sse ? grs_op_Intrinsic_reg_sse_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_reg_sse_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Method_IRG = ext_grs_lookup_op("Method_IRG");
+  grs_op_Method_IRG = grs_op_Method_IRG ? grs_op_Method_IRG : new_ir_op(get_next_ir_opcode(), "Method_IRG", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Class = ext_grs_lookup_op("Class");
+  grs_op_Class = grs_op_Class ? grs_op_Class : new_ir_op(get_next_ir_opcode(), "Class", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Quot = ext_grs_lookup_op("Quot");
+  grs_op_Quot = grs_op_Quot ? grs_op_Quot : new_ir_op(get_next_ir_opcode(), "Quot", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mode = ext_grs_lookup_op("Mode");
+  grs_op_Mode = grs_op_Mode ? grs_op_Mode : new_ir_op(get_next_ir_opcode(), "Mode", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_StartBlock = ext_grs_lookup_op("StartBlock");
+  grs_op_StartBlock = grs_op_StartBlock ? grs_op_StartBlock : new_ir_op(get_next_ir_opcode(), "StartBlock", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Return = ext_grs_lookup_op("Return");
+  grs_op_Return = grs_op_Return ? grs_op_Return : new_ir_op(get_next_ir_opcode(), "Return", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_addr_addr_store = ext_grs_lookup_op("Intrinsic_addr_addr_store");
+  grs_op_Intrinsic_addr_addr_store = grs_op_Intrinsic_addr_addr_store ? grs_op_Intrinsic_addr_addr_store : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_addr_store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_NoMem = ext_grs_lookup_op("NoMem");
+  grs_op_NoMem = grs_op_NoMem ? grs_op_NoMem : new_ir_op(get_next_ir_opcode(), "NoMem", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+} /* init node ops and modes */
+
+/* functions for evaluation of conditions of action KillAllButEnd */
+
+/* functions for building the pattern of action KillAllButEnd */
+static _inline ext_grs_action_t *grs_action_KillAllButEnd_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillAllButEnd");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(x) = IR_node \ [node type End]*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillAllButEnd */
+
+
+/* functions for evaluation of conditions of action KillBlock */
+
+/* functions for building the pattern of action KillBlock */
+static _inline ext_grs_action_t *grs_action_KillBlock_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillBlock");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b) = Block \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_Block, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillBlock */
+
+
+/* functions for evaluation of conditions of action KillCall */
+
+/* functions for building the pattern of action KillCall */
+static _inline ext_grs_action_t *grs_action_KillCall_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillCall");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(x) = Call \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_Call, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillCall */
+
+
+/* functions for evaluation of conditions of action KillConst */
+
+/* functions for building the pattern of action KillConst */
+static _inline ext_grs_action_t *grs_action_KillConst_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillConst");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b) = Const \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_Const, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillConst */
+
+
+/* functions for evaluation of conditions of action KillEntity */
+
+/* functions for building the pattern of action KillEntity */
+static _inline ext_grs_action_t *grs_action_KillEntity_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillEntity");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(e) = Entity \ []*/
+    ext_grs_node_t *n_e = ext_grs_act_add_node(pattern, "e", grs_op_Entity, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillEntity */
+
+
+/* functions for evaluation of conditions of action KillMemoryEdges */
+
+/* functions for building the pattern of action KillMemoryEdges */
+static _inline ext_grs_action_t *grs_action_KillMemoryEdges_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillMemoryEdges");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(y) = Node \ []*/
+    ext_grs_node_t *n_y = ext_grs_act_add_node(pattern, "y", grs_op_Node, mode_ANY, 0);
+    /* TODO typeof(x) = Node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_Node, mode_ANY, 1);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_y, n_x, 0);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillMemoryEdges */
+
+
+/* functions for evaluation of conditions of action KillMethod_IRG */
+
+/* functions for building the pattern of action KillMethod_IRG */
+static _inline ext_grs_action_t *grs_action_KillMethod_IRG_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillMethod_IRG");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b) = Method_IRG \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_Method_IRG, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillMethod_IRG */
+
+
+/* functions for evaluation of conditions of action KillMode */
+
+/* functions for building the pattern of action KillMode */
+static _inline ext_grs_action_t *grs_action_KillMode_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillMode");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(m) = Mode \ []*/
+    ext_grs_node_t *n_m = ext_grs_act_add_node(pattern, "m", grs_op_Mode, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillMode */
+
+
+/* functions for evaluation of conditions of action KillType */
+
+/* functions for building the pattern of action KillType */
+static _inline ext_grs_action_t *grs_action_KillType_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillType");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(t) = Type \ []*/
+    ext_grs_node_t *n_t = ext_grs_act_add_node(pattern, "t", grs_op_Type, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillType */
+
+
+/* functions for evaluation of conditions of action KillUselessConv */
+static int grs_cond_func_9202(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ <=  0 /* TODO attr access */;
+}
+
+/* functions for building the pattern of action KillUselessConv */
+static _inline ext_grs_action_t *grs_action_KillUselessConv_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "KillUselessConv");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(m) = Mode \ []*/
+    ext_grs_node_t *n_m = ext_grs_act_add_node(pattern, "m", grs_op_Mode, mode_ANY, 0);
+/* mode edge: edge $edge5*/
+    /* TODO typeof(c2) = Conv \ []*/
+    ext_grs_node_t *n_c2 = ext_grs_act_add_node(pattern, "c2", grs_op_Conv, mode_ANY, 1);
+    /* TODO typeof(m1) = Mode \ []*/
+    ext_grs_node_t *n_m1 = ext_grs_act_add_node(pattern, "m1", grs_op_Mode, mode_ANY, 2);
+/* mode edge: edge $edge6*/
+    /* TODO typeof(b) = IR_node \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_IR_node, mode_ANY, 3);
+/* mode edge: edge $edge4*/
+    /* TODO typeof(c1) = Conv \ []*/
+    ext_grs_node_t *n_c1 = ext_grs_act_add_node(pattern, "c1", grs_op_Conv, mode_ANY, 4);
+/* mode edge: edge $edge3*/
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 5);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_m, n_a, 0);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_m, n_c2, 1);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_c2, n_c1, 2);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_c1, n_a, 3);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_m, n_b, 4);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_b, n_c2, 5);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_m1, n_c1, 6);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[2] = {n_m, n_m1};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_9202, pattern, 2, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* KillUselessConv */
+
+
+/* functions for evaluation of conditions of action MAX */
+
+/* functions for building the pattern of action MAX */
+static _inline ext_grs_action_t *grs_action_MAX_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "MAX");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(y) = IR_node \ []*/
+    ext_grs_node_t *n_y = ext_grs_act_add_node(pattern, "y", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(bb1) = Block \ []*/
+    ext_grs_node_t *n_bb1 = ext_grs_act_add_node(pattern, "bb1", grs_op_Block, mode_ANY, 1);
+    /* TODO typeof(irg) = Method_IRG \ []*/
+    ext_grs_node_t *n_irg = ext_grs_act_add_node(pattern, "irg", grs_op_Method_IRG, mode_ANY, 2);
+    /* TODO typeof(cmp) = Cmp \ []*/
+    ext_grs_node_t *n_cmp = ext_grs_act_add_node(pattern, "cmp", grs_op_Cmp, mode_ANY, 3);
+    /* TODO typeof(Pb) = Proj \ []*/
+    ext_grs_node_t *n_Pb = ext_grs_act_add_node(pattern, "Pb", grs_op_Proj, mode_ANY, 4);
+    /* TODO typeof(cnd) = Cond \ []*/
+    ext_grs_node_t *n_cnd = ext_grs_act_add_node(pattern, "cnd", grs_op_Cond, mode_ANY, 5);
+    /* TODO typeof(Px1) = Proj \ []*/
+    ext_grs_node_t *n_Px1 = ext_grs_act_add_node(pattern, "Px1", grs_op_Proj, mode_ANY, 6);
+    /* TODO typeof(phi) = Phi \ []*/
+    ext_grs_node_t *n_phi = ext_grs_act_add_node(pattern, "phi", grs_op_Phi, mode_ANY, 7);
+    /* TODO typeof(Px0) = Proj \ []*/
+    ext_grs_node_t *n_Px0 = ext_grs_act_add_node(pattern, "Px0", grs_op_Proj, mode_ANY, 8);
+    /* TODO typeof(bb0) = Block \ []*/
+    ext_grs_node_t *n_bb0 = ext_grs_act_add_node(pattern, "bb0", grs_op_Block, mode_ANY, 9);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 10);
+    /* TODO typeof(jmp) = Jmp \ []*/
+    ext_grs_node_t *n_jmp = ext_grs_act_add_node(pattern, "jmp", grs_op_Jmp, mode_ANY, 11);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 12);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_Pb, n_cnd, 0);
+    ext_grs_edge_t *e__edge15 = ext_grs_act_add_edge(pattern, "_edge15", ext_grs_NO_EDGE_POS, n_irg, n_bb, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_cmp, 2);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_cnd, n_Px1, 3);
+    ext_grs_edge_t *e__edge11 = ext_grs_act_add_edge(pattern, "_edge11", ext_grs_NO_EDGE_POS, n_bb, n_Px0, 4);
+    ext_grs_edge_t *e__edge12 = ext_grs_act_add_edge(pattern, "_edge12", ext_grs_NO_EDGE_POS, n_bb, n_Px1, 5);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_Px0, n_bb0, 6);
+    ext_grs_edge_t *e__edge16 = ext_grs_act_add_edge(pattern, "_edge16", ext_grs_NO_EDGE_POS, n_irg, n_bb0, 7);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_cnd, n_Px0, 8);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_y, n_cmp, 9);
+    ext_grs_edge_t *e__edge7 = ext_grs_act_add_edge(pattern, "_edge7", ext_grs_NO_EDGE_POS, n_Px1, n_bb1, 10);
+    ext_grs_edge_t *e__edge13 = ext_grs_act_add_edge(pattern, "_edge13", ext_grs_NO_EDGE_POS, n_bb0, n_jmp, 11);
+    ext_grs_edge_t *e__edge17 = ext_grs_act_add_edge(pattern, "_edge17", ext_grs_NO_EDGE_POS, n_irg, n_bb1, 12);
+    ext_grs_edge_t *e__edge14 = ext_grs_act_add_edge(pattern, "_edge14", ext_grs_NO_EDGE_POS, n_bb1, n_phi, 13);
+    ext_grs_edge_t *e__edge8 = ext_grs_act_add_edge(pattern, "_edge8", ext_grs_NO_EDGE_POS, n_jmp, n_bb1, 14);
+    ext_grs_edge_t *e__edge10 = ext_grs_act_add_edge(pattern, "_edge10", ext_grs_NO_EDGE_POS, n_y, n_phi, 15);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_cmp, n_Pb, 16);
+    ext_grs_edge_t *e__edge9 = ext_grs_act_add_edge(pattern, "_edge9", ext_grs_NO_EDGE_POS, n_x, n_phi, 17);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* MAX */
+
+
+/* functions for evaluation of conditions of action MAX2 */
+
+/* functions for building the pattern of action MAX2 */
+static _inline ext_grs_action_t *grs_action_MAX2_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "MAX2");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(y) = IR_node \ []*/
+    ext_grs_node_t *n_y = ext_grs_act_add_node(pattern, "y", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(bb1) = Block \ []*/
+    ext_grs_node_t *n_bb1 = ext_grs_act_add_node(pattern, "bb1", grs_op_Block, mode_ANY, 1);
+    /* TODO typeof(irg) = Method_IRG \ []*/
+    ext_grs_node_t *n_irg = ext_grs_act_add_node(pattern, "irg", grs_op_Method_IRG, mode_ANY, 2);
+    /* TODO typeof(cmp) = Cmp \ []*/
+    ext_grs_node_t *n_cmp = ext_grs_act_add_node(pattern, "cmp", grs_op_Cmp, mode_ANY, 3);
+    /* TODO typeof(Pb) = Proj \ []*/
+    ext_grs_node_t *n_Pb = ext_grs_act_add_node(pattern, "Pb", grs_op_Proj, mode_ANY, 4);
+    /* TODO typeof(cnd) = Cond \ []*/
+    ext_grs_node_t *n_cnd = ext_grs_act_add_node(pattern, "cnd", grs_op_Cond, mode_ANY, 5);
+    /* TODO typeof(Px1) = Proj \ []*/
+    ext_grs_node_t *n_Px1 = ext_grs_act_add_node(pattern, "Px1", grs_op_Proj, mode_ANY, 6);
+    /* TODO typeof(phi) = Phi \ []*/
+    ext_grs_node_t *n_phi = ext_grs_act_add_node(pattern, "phi", grs_op_Phi, mode_ANY, 7);
+    /* TODO typeof(Px0) = Proj \ []*/
+    ext_grs_node_t *n_Px0 = ext_grs_act_add_node(pattern, "Px0", grs_op_Proj, mode_ANY, 8);
+    /* TODO typeof(bb0) = Block \ []*/
+    ext_grs_node_t *n_bb0 = ext_grs_act_add_node(pattern, "bb0", grs_op_Block, mode_ANY, 9);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 10);
+    /* TODO typeof(jmp) = Jmp \ []*/
+    ext_grs_node_t *n_jmp = ext_grs_act_add_node(pattern, "jmp", grs_op_Jmp, mode_ANY, 11);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 12);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_Pb, n_cnd, 0);
+    ext_grs_edge_t *e__edge15 = ext_grs_act_add_edge(pattern, "_edge15", ext_grs_NO_EDGE_POS, n_irg, n_bb, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_cmp, 2);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_cnd, n_Px1, 3);
+    ext_grs_edge_t *e__edge11 = ext_grs_act_add_edge(pattern, "_edge11", ext_grs_NO_EDGE_POS, n_bb, n_Px0, 4);
+    ext_grs_edge_t *e__edge12 = ext_grs_act_add_edge(pattern, "_edge12", ext_grs_NO_EDGE_POS, n_bb, n_Px1, 5);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_Px0, n_bb0, 6);
+    ext_grs_edge_t *e__edge16 = ext_grs_act_add_edge(pattern, "_edge16", ext_grs_NO_EDGE_POS, n_irg, n_bb0, 7);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_cnd, n_Px0, 8);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_y, n_cmp, 9);
+    ext_grs_edge_t *e__edge7 = ext_grs_act_add_edge(pattern, "_edge7", ext_grs_NO_EDGE_POS, n_Px1, n_bb1, 10);
+    ext_grs_edge_t *e__edge13 = ext_grs_act_add_edge(pattern, "_edge13", ext_grs_NO_EDGE_POS, n_bb0, n_jmp, 11);
+    ext_grs_edge_t *e__edge17 = ext_grs_act_add_edge(pattern, "_edge17", ext_grs_NO_EDGE_POS, n_irg, n_bb1, 12);
+    ext_grs_edge_t *e__edge14 = ext_grs_act_add_edge(pattern, "_edge14", ext_grs_NO_EDGE_POS, n_bb1, n_phi, 13);
+    ext_grs_edge_t *e__edge8 = ext_grs_act_add_edge(pattern, "_edge8", ext_grs_NO_EDGE_POS, n_jmp, n_bb1, 14);
+    ext_grs_edge_t *e__edge10 = ext_grs_act_add_edge(pattern, "_edge10", ext_grs_NO_EDGE_POS, n_y, n_phi, 15);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_cmp, n_Pb, 16);
+    ext_grs_edge_t *e__edge9 = ext_grs_act_add_edge(pattern, "_edge9", ext_grs_NO_EDGE_POS, n_x, n_phi, 17);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* MAX2 */
+
+
+/* functions for evaluation of conditions of action PBQP_0a */
+
+/* functions for building the pattern of action PBQP_0a */
+static _inline ext_grs_action_t *grs_action_PBQP_0a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_0a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(x_0) = IR_node \ []*/
+      ext_grs_node_t *n_x_0 = ext_grs_act_add_related_node(pattern, "x_0", grs_op_IR_node, mode_ANY, 0, n_x);
+      /* TODO typeof(c) = IR_node \ []*/
+      ext_grs_node_t *n_c = ext_grs_act_add_node(pattern, "c", grs_op_IR_node, mode_ANY, 1);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_1 = ext_grs_act_add_edge(pattern, "_edge0_1", ext_grs_NO_EDGE_POS, n_c, n_x_0, 0);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(d) = IR_node \ []*/
+      ext_grs_node_t *n_d = ext_grs_act_add_node(pattern, "d", grs_op_IR_node, mode_ANY, 2);
+      /* TODO typeof(x_2) = IR_node \ []*/
+      ext_grs_node_t *n_x_2 = ext_grs_act_add_related_node(pattern, "x_2", grs_op_IR_node, mode_ANY, 0, n_x);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_3 = ext_grs_act_add_edge(pattern, "_edge0_3", ext_grs_NO_EDGE_POS, n_x_2, n_d, 1);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_0a */
+
+
+/* functions for evaluation of conditions of action PBQP_1a */
+
+/* functions for building the pattern of action PBQP_1a */
+static _inline ext_grs_action_t *grs_action_PBQP_1a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_1a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 1);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_a, 0);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(x_4) = IR_node \ []*/
+      ext_grs_node_t *n_x_4 = ext_grs_act_add_related_node(pattern, "x_4", grs_op_IR_node, mode_ANY, 0, n_x);
+      /* TODO typeof(c) = IR_node \ []*/
+      ext_grs_node_t *n_c = ext_grs_act_add_node(pattern, "c", grs_op_IR_node, mode_ANY, 2);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_5 = ext_grs_act_add_edge(pattern, "_edge0_5", ext_grs_NO_EDGE_POS, n_c, n_x_4, 1);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(d) = IR_node \ []*/
+      ext_grs_node_t *n_d = ext_grs_act_add_node(pattern, "d", grs_op_IR_node, mode_ANY, 3);
+      /* TODO typeof(x_6) = IR_node \ []*/
+      ext_grs_node_t *n_x_6 = ext_grs_act_add_related_node(pattern, "x_6", grs_op_IR_node, mode_ANY, 0, n_x);
+      /* TODO typeof(a_7) = IR_node \ []*/
+      ext_grs_node_t *n_a_7 = ext_grs_act_add_related_node(pattern, "a_7", grs_op_IR_node, mode_ANY, 1, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_8 = ext_grs_act_add_related_edge(pattern, "_edge0_8", ext_grs_NO_EDGE_POS, n_x_6, n_a_7, 0, e__edge0);
+      ext_grs_edge_t *e__edge0_9 = ext_grs_act_add_edge(pattern, "_edge0_9", ext_grs_NO_EDGE_POS, n_x_6, n_d, 2);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_1a */
+
+
+/* functions for evaluation of conditions of action PBQP_1b */
+
+/* functions for building the pattern of action PBQP_1b */
+static _inline ext_grs_action_t *grs_action_PBQP_1b_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_1b");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 1);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_a, n_x, 0);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(x_10) = IR_node \ []*/
+      ext_grs_node_t *n_x_10 = ext_grs_act_add_related_node(pattern, "x_10", grs_op_IR_node, mode_ANY, 0, n_x);
+      /* TODO typeof(c) = IR_node \ []*/
+      ext_grs_node_t *n_c = ext_grs_act_add_node(pattern, "c", grs_op_IR_node, mode_ANY, 2);
+      /* TODO typeof(a_11) = IR_node \ []*/
+      ext_grs_node_t *n_a_11 = ext_grs_act_add_related_node(pattern, "a_11", grs_op_IR_node, mode_ANY, 1, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_12 = ext_grs_act_add_related_edge(pattern, "_edge0_12", ext_grs_NO_EDGE_POS, n_a_11, n_x_10, 0, e__edge0);
+      ext_grs_edge_t *e__edge0_13 = ext_grs_act_add_edge(pattern, "_edge0_13", ext_grs_NO_EDGE_POS, n_c, n_x_10, 1);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(d) = IR_node \ []*/
+      ext_grs_node_t *n_d = ext_grs_act_add_node(pattern, "d", grs_op_IR_node, mode_ANY, 3);
+      /* TODO typeof(x_14) = IR_node \ []*/
+      ext_grs_node_t *n_x_14 = ext_grs_act_add_related_node(pattern, "x_14", grs_op_IR_node, mode_ANY, 0, n_x);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_15 = ext_grs_act_add_edge(pattern, "_edge0_15", ext_grs_NO_EDGE_POS, n_x_14, n_d, 2);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_1b */
+
+
+/* functions for evaluation of conditions of action PBQP_1c */
+
+/* functions for building the pattern of action PBQP_1c */
+static _inline ext_grs_action_t *grs_action_PBQP_1c_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_1c");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 1);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e2 = ext_grs_act_add_edge(pattern, "e2", ext_grs_NO_EDGE_POS, n_a, n_x, 0);
+    ext_grs_edge_t *e_e1 = ext_grs_act_add_edge(pattern, "e1", ext_grs_NO_EDGE_POS, n_a, n_x, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_1c */
+
+
+/* functions for evaluation of conditions of action PBQP_1d */
+
+/* functions for building the pattern of action PBQP_1d */
+static _inline ext_grs_action_t *grs_action_PBQP_1d_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_1d");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 1);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e2 = ext_grs_act_add_edge(pattern, "e2", ext_grs_NO_EDGE_POS, n_x, n_a, 0);
+    ext_grs_edge_t *e_e1 = ext_grs_act_add_edge(pattern, "e1", ext_grs_NO_EDGE_POS, n_a, n_x, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_1d */
+
+
+/* functions for evaluation of conditions of action PBQP_2a */
+
+/* functions for building the pattern of action PBQP_2a */
+static _inline ext_grs_action_t *grs_action_PBQP_2a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_2a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b) = IR_node \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_x, n_b, 0);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_a, n_x, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(x_16) = IR_node \ []*/
+      ext_grs_node_t *n_x_16 = ext_grs_act_add_related_node(pattern, "x_16", grs_op_IR_node, mode_ANY, 1, n_x);
+      /* TODO typeof(c) = IR_node \ []*/
+      ext_grs_node_t *n_c = ext_grs_act_add_node(pattern, "c", grs_op_IR_node, mode_ANY, 3);
+      /* TODO typeof(a_17) = IR_node \ []*/
+      ext_grs_node_t *n_a_17 = ext_grs_act_add_related_node(pattern, "a_17", grs_op_IR_node, mode_ANY, 2, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_18 = ext_grs_act_add_related_edge(pattern, "_edge0_18", ext_grs_NO_EDGE_POS, n_a_17, n_x_16, 1, e__edge0);
+      ext_grs_edge_t *e__edge0_19 = ext_grs_act_add_edge(pattern, "_edge0_19", ext_grs_NO_EDGE_POS, n_c, n_x_16, 2);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(d) = IR_node \ []*/
+      ext_grs_node_t *n_d = ext_grs_act_add_node(pattern, "d", grs_op_IR_node, mode_ANY, 4);
+      /* TODO typeof(b_20) = IR_node \ []*/
+      ext_grs_node_t *n_b_20 = ext_grs_act_add_related_node(pattern, "b_20", grs_op_IR_node, mode_ANY, 0, n_b);
+      /* TODO typeof(x_21) = IR_node \ []*/
+      ext_grs_node_t *n_x_21 = ext_grs_act_add_related_node(pattern, "x_21", grs_op_IR_node, mode_ANY, 1, n_x);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge1_22 = ext_grs_act_add_related_edge(pattern, "_edge1_22", ext_grs_NO_EDGE_POS, n_x_21, n_b_20, 0, e__edge1);
+      ext_grs_edge_t *e__edge0_23 = ext_grs_act_add_edge(pattern, "_edge0_23", ext_grs_NO_EDGE_POS, n_x_21, n_d, 3);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_2a */
+
+
+/* functions for evaluation of conditions of action PBQP_2b */
+
+/* functions for building the pattern of action PBQP_2b */
+static _inline ext_grs_action_t *grs_action_PBQP_2b_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_2b");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b) = IR_node \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_b, n_x, 0);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_a, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b_24) = IR_node \ []*/
+      ext_grs_node_t *n_b_24 = ext_grs_act_add_related_node(pattern, "b_24", grs_op_IR_node, mode_ANY, 0, n_b);
+      /* TODO typeof(x_25) = IR_node \ []*/
+      ext_grs_node_t *n_x_25 = ext_grs_act_add_related_node(pattern, "x_25", grs_op_IR_node, mode_ANY, 1, n_x);
+      /* TODO typeof(c) = IR_node \ []*/
+      ext_grs_node_t *n_c = ext_grs_act_add_node(pattern, "c", grs_op_IR_node, mode_ANY, 3);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge1_26 = ext_grs_act_add_related_edge(pattern, "_edge1_26", ext_grs_NO_EDGE_POS, n_b_24, n_x_25, 0, e__edge1);
+      ext_grs_edge_t *e__edge0_27 = ext_grs_act_add_edge(pattern, "_edge0_27", ext_grs_NO_EDGE_POS, n_c, n_x_25, 2);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(d) = IR_node \ []*/
+      ext_grs_node_t *n_d = ext_grs_act_add_node(pattern, "d", grs_op_IR_node, mode_ANY, 4);
+      /* TODO typeof(x_28) = IR_node \ []*/
+      ext_grs_node_t *n_x_28 = ext_grs_act_add_related_node(pattern, "x_28", grs_op_IR_node, mode_ANY, 1, n_x);
+      /* TODO typeof(a_29) = IR_node \ []*/
+      ext_grs_node_t *n_a_29 = ext_grs_act_add_related_node(pattern, "a_29", grs_op_IR_node, mode_ANY, 2, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_30 = ext_grs_act_add_related_edge(pattern, "_edge0_30", ext_grs_NO_EDGE_POS, n_x_28, n_a_29, 1, e__edge0);
+      ext_grs_edge_t *e__edge0_31 = ext_grs_act_add_edge(pattern, "_edge0_31", ext_grs_NO_EDGE_POS, n_x_28, n_d, 3);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_2b */
+
+
+/* functions for evaluation of conditions of action PBQP_2c */
+
+/* functions for building the pattern of action PBQP_2c */
+static _inline ext_grs_action_t *grs_action_PBQP_2c_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_2c");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b) = IR_node \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_x, n_b, 0);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_a, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(x_32) = IR_node \ []*/
+      ext_grs_node_t *n_x_32 = ext_grs_act_add_related_node(pattern, "x_32", grs_op_IR_node, mode_ANY, 1, n_x);
+      /* TODO typeof(c) = IR_node \ []*/
+      ext_grs_node_t *n_c = ext_grs_act_add_node(pattern, "c", grs_op_IR_node, mode_ANY, 3);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_33 = ext_grs_act_add_edge(pattern, "_edge0_33", ext_grs_NO_EDGE_POS, n_c, n_x_32, 2);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(d) = IR_node \ []*/
+      ext_grs_node_t *n_d = ext_grs_act_add_node(pattern, "d", grs_op_IR_node, mode_ANY, 4);
+      /* TODO typeof(b_34) = IR_node \ []*/
+      ext_grs_node_t *n_b_34 = ext_grs_act_add_related_node(pattern, "b_34", grs_op_IR_node, mode_ANY, 0, n_b);
+      /* TODO typeof(x_35) = IR_node \ []*/
+      ext_grs_node_t *n_x_35 = ext_grs_act_add_related_node(pattern, "x_35", grs_op_IR_node, mode_ANY, 1, n_x);
+      /* TODO typeof(a_36) = IR_node \ []*/
+      ext_grs_node_t *n_a_36 = ext_grs_act_add_related_node(pattern, "a_36", grs_op_IR_node, mode_ANY, 2, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge1_37 = ext_grs_act_add_related_edge(pattern, "_edge1_37", ext_grs_NO_EDGE_POS, n_x_35, n_b_34, 0, e__edge1);
+      ext_grs_edge_t *e__edge0_38 = ext_grs_act_add_related_edge(pattern, "_edge0_38", ext_grs_NO_EDGE_POS, n_x_35, n_a_36, 1, e__edge0);
+      ext_grs_edge_t *e__edge0_39 = ext_grs_act_add_edge(pattern, "_edge0_39", ext_grs_NO_EDGE_POS, n_x_35, n_d, 3);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_2c */
+
+
+/* functions for evaluation of conditions of action PBQP_2d */
+
+/* functions for building the pattern of action PBQP_2d */
+static _inline ext_grs_action_t *grs_action_PBQP_2d_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "PBQP_2d");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b) = IR_node \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(a) = IR_node \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_IR_node, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_b, n_x, 0);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_a, n_x, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b_40) = IR_node \ []*/
+      ext_grs_node_t *n_b_40 = ext_grs_act_add_related_node(pattern, "b_40", grs_op_IR_node, mode_ANY, 0, n_b);
+      /* TODO typeof(x_41) = IR_node \ []*/
+      ext_grs_node_t *n_x_41 = ext_grs_act_add_related_node(pattern, "x_41", grs_op_IR_node, mode_ANY, 1, n_x);
+      /* TODO typeof(c) = IR_node \ []*/
+      ext_grs_node_t *n_c = ext_grs_act_add_node(pattern, "c", grs_op_IR_node, mode_ANY, 3);
+      /* TODO typeof(a_42) = IR_node \ []*/
+      ext_grs_node_t *n_a_42 = ext_grs_act_add_related_node(pattern, "a_42", grs_op_IR_node, mode_ANY, 2, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge1_43 = ext_grs_act_add_related_edge(pattern, "_edge1_43", ext_grs_NO_EDGE_POS, n_b_40, n_x_41, 0, e__edge1);
+      ext_grs_edge_t *e__edge0_44 = ext_grs_act_add_related_edge(pattern, "_edge0_44", ext_grs_NO_EDGE_POS, n_a_42, n_x_41, 1, e__edge0);
+      ext_grs_edge_t *e__edge0_45 = ext_grs_act_add_edge(pattern, "_edge0_45", ext_grs_NO_EDGE_POS, n_c, n_x_41, 2);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(d) = IR_node \ []*/
+      ext_grs_node_t *n_d = ext_grs_act_add_node(pattern, "d", grs_op_IR_node, mode_ANY, 4);
+      /* TODO typeof(x_46) = IR_node \ []*/
+      ext_grs_node_t *n_x_46 = ext_grs_act_add_related_node(pattern, "x_46", grs_op_IR_node, mode_ANY, 1, n_x);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_47 = ext_grs_act_add_edge(pattern, "_edge0_47", ext_grs_NO_EDGE_POS, n_x_46, n_d, 3);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* PBQP_2d */
+
+
+/* functions for evaluation of conditions of action V2LD_a */
+
+/* functions for building the pattern of action V2LD_a */
+static _inline ext_grs_action_t *grs_action_V2LD_a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "V2LD_a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(index) = IR_node \ []*/
+    ext_grs_node_t *n_index = ext_grs_act_add_node(pattern, "index", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(m_2) = Mul \ []*/
+    ext_grs_node_t *n_m_2 = ext_grs_act_add_node(pattern, "m_2", grs_op_Mul, mode_ANY, 1);
+    /* TODO typeof(ld_2) = Load \ []*/
+    ext_grs_node_t *n_ld_2 = ext_grs_act_add_node(pattern, "ld_2", grs_op_Load, mode_ANY, 2);
+    /* TODO typeof(a1_2) = Add \ []*/
+    ext_grs_node_t *n_a1_2 = ext_grs_act_add_node(pattern, "a1_2", grs_op_Add, mode_ANY, 3);
+    /* TODO typeof(ld_1) = Load \ []*/
+    ext_grs_node_t *n_ld_1 = ext_grs_act_add_node(pattern, "ld_1", grs_op_Load, mode_ANY, 4);
+    /* TODO typeof(a2_2) = Add \ []*/
+    ext_grs_node_t *n_a2_2 = ext_grs_act_add_node(pattern, "a2_2", grs_op_Add, mode_ANY, 5);
+    /* TODO typeof(m_1) = Mul \ []*/
+    ext_grs_node_t *n_m_1 = ext_grs_act_add_node(pattern, "m_1", grs_op_Mul, mode_ANY, 6);
+    /* TODO typeof(a_1) = Add \ []*/
+    ext_grs_node_t *n_a_1 = ext_grs_act_add_node(pattern, "a_1", grs_op_Add, mode_ANY, 7);
+    /* TODO typeof(size) = Const \ []*/
+    ext_grs_node_t *n_size = ext_grs_act_add_node(pattern, "size", grs_op_Const, mode_ANY, 8);
+    /* TODO typeof(one) = Const \ []*/
+    ext_grs_node_t *n_one = ext_grs_act_add_node(pattern, "one", grs_op_Const, mode_ANY, 9);
+    /* TODO typeof(addr) = IR_node \ []*/
+    ext_grs_node_t *n_addr = ext_grs_act_add_node(pattern, "addr", grs_op_IR_node, mode_ANY, 10);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_size, n_m_1, 0);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_a1_2, n_ld_2, 1);
+    ext_grs_edge_t *e__edge7 = ext_grs_act_add_edge(pattern, "_edge7", ext_grs_NO_EDGE_POS, n_m_2, n_a1_2, 2);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_addr, n_a_1, 3);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_a_1, n_ld_1, 4);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_addr, n_a1_2, 5);
+    ext_grs_edge_t *e__edge8 = ext_grs_act_add_edge(pattern, "_edge8", ext_grs_NO_EDGE_POS, n_size, n_m_2, 6);
+    ext_grs_edge_t *e__edge10 = ext_grs_act_add_edge(pattern, "_edge10", ext_grs_NO_EDGE_POS, n_one, n_a2_2, 7);
+    ext_grs_edge_t *e__edge11 = ext_grs_act_add_edge(pattern, "_edge11", ext_grs_NO_EDGE_POS, n_index, n_a2_2, 8);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_m_1, n_a_1, 9);
+    ext_grs_edge_t *e__edge9 = ext_grs_act_add_edge(pattern, "_edge9", ext_grs_NO_EDGE_POS, n_a2_2, n_m_2, 10);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_index, n_m_1, 11);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* V2LD_a */
+
+
+/* functions for evaluation of conditions of action V2LD_b */
+
+/* functions for building the pattern of action V2LD_b */
+static _inline ext_grs_action_t *grs_action_V2LD_b_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "V2LD_b");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(index) = IR_node \ []*/
+    ext_grs_node_t *n_index = ext_grs_act_add_node(pattern, "index", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(m_2) = Mul \ []*/
+    ext_grs_node_t *n_m_2 = ext_grs_act_add_node(pattern, "m_2", grs_op_Mul, mode_ANY, 1);
+    /* TODO typeof(ld_1) = Load \ []*/
+    ext_grs_node_t *n_ld_1 = ext_grs_act_add_node(pattern, "ld_1", grs_op_Load, mode_ANY, 2);
+    /* TODO typeof(size) = Const \ []*/
+    ext_grs_node_t *n_size = ext_grs_act_add_node(pattern, "size", grs_op_Const, mode_ANY, 3);
+    /* TODO typeof(c2) = Const \ []*/
+    ext_grs_node_t *n_c2 = ext_grs_act_add_node(pattern, "c2", grs_op_Const, mode_ANY, 4);
+    /* TODO typeof(a1_1) = Add \ []*/
+    ext_grs_node_t *n_a1_1 = ext_grs_act_add_node(pattern, "a1_1", grs_op_Add, mode_ANY, 5);
+    /* TODO typeof(ld_2) = Load \ []*/
+    ext_grs_node_t *n_ld_2 = ext_grs_act_add_node(pattern, "ld_2", grs_op_Load, mode_ANY, 6);
+    /* TODO typeof(a1_2) = Add \ []*/
+    ext_grs_node_t *n_a1_2 = ext_grs_act_add_node(pattern, "a1_2", grs_op_Add, mode_ANY, 7);
+    /* TODO typeof(a2_2) = Add \ []*/
+    ext_grs_node_t *n_a2_2 = ext_grs_act_add_node(pattern, "a2_2", grs_op_Add, mode_ANY, 8);
+    /* TODO typeof(m_1) = Mul \ []*/
+    ext_grs_node_t *n_m_1 = ext_grs_act_add_node(pattern, "m_1", grs_op_Mul, mode_ANY, 9);
+    /* TODO typeof(a2_1) = Add \ []*/
+    ext_grs_node_t *n_a2_1 = ext_grs_act_add_node(pattern, "a2_1", grs_op_Add, mode_ANY, 10);
+    /* TODO typeof(c1) = Const \ []*/
+    ext_grs_node_t *n_c1 = ext_grs_act_add_node(pattern, "c1", grs_op_Const, mode_ANY, 11);
+    /* TODO typeof(addr) = IR_node \ []*/
+    ext_grs_node_t *n_addr = ext_grs_act_add_node(pattern, "addr", grs_op_IR_node, mode_ANY, 12);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_size, n_m_1, 0);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_a1_1, n_ld_1, 1);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_index, n_a2_1, 2);
+    ext_grs_edge_t *e__edge11 = ext_grs_act_add_edge(pattern, "_edge11", ext_grs_NO_EDGE_POS, n_a2_2, n_m_2, 3);
+    ext_grs_edge_t *e__edge12 = ext_grs_act_add_edge(pattern, "_edge12", ext_grs_NO_EDGE_POS, n_c2, n_a2_2, 4);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_a2_1, n_m_1, 5);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_c1, n_a2_1, 6);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_addr, n_a1_1, 7);
+    ext_grs_edge_t *e__edge7 = ext_grs_act_add_edge(pattern, "_edge7", ext_grs_NO_EDGE_POS, n_a1_2, n_ld_2, 8);
+    ext_grs_edge_t *e__edge13 = ext_grs_act_add_edge(pattern, "_edge13", ext_grs_NO_EDGE_POS, n_index, n_a2_2, 9);
+    ext_grs_edge_t *e__edge8 = ext_grs_act_add_edge(pattern, "_edge8", ext_grs_NO_EDGE_POS, n_addr, n_a1_2, 10);
+    ext_grs_edge_t *e__edge10 = ext_grs_act_add_edge(pattern, "_edge10", ext_grs_NO_EDGE_POS, n_size, n_m_2, 11);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_m_1, n_a1_1, 12);
+    ext_grs_edge_t *e__edge9 = ext_grs_act_add_edge(pattern, "_edge9", ext_grs_NO_EDGE_POS, n_m_2, n_a1_2, 13);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* V2LD_b */
+
+
+/* functions for evaluation of conditions of action V2LD_c */
+
+/* functions for building the pattern of action V2LD_c */
+static _inline ext_grs_action_t *grs_action_V2LD_c_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "V2LD_c");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(ld_2) = Load \ []*/
+    ext_grs_node_t *n_ld_2 = ext_grs_act_add_node(pattern, "ld_2", grs_op_Load, mode_ANY, 0);
+    /* TODO typeof(ld_1) = Load \ []*/
+    ext_grs_node_t *n_ld_1 = ext_grs_act_add_node(pattern, "ld_1", grs_op_Load, mode_ANY, 1);
+    /* TODO typeof(displ) = Const \ []*/
+    ext_grs_node_t *n_displ = ext_grs_act_add_node(pattern, "displ", grs_op_Const, mode_ANY, 2);
+    /* TODO typeof(addr) = Phi \ []*/
+    ext_grs_node_t *n_addr = ext_grs_act_add_node(pattern, "addr", grs_op_Phi, mode_ANY, 3);
+    /* TODO typeof(a) = Add \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_Add, mode_ANY, 4);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 5);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_addr, n_a, 0);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_bb, n_ld_2, 1);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_a, n_ld_2, 2);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_addr, n_ld_1, 3);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_displ, n_a, 4);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_bb, n_ld_1, 5);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* V2LD_c */
+
+
+/* functions for evaluation of conditions of action V2LD_d */
+
+/* functions for building the pattern of action V2LD_d */
+static _inline ext_grs_action_t *grs_action_V2LD_d_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "V2LD_d");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(ld_2) = Load \ []*/
+    ext_grs_node_t *n_ld_2 = ext_grs_act_add_node(pattern, "ld_2", grs_op_Load, mode_ANY, 0);
+    /* TODO typeof(dis_1) = Const \ []*/
+    ext_grs_node_t *n_dis_1 = ext_grs_act_add_node(pattern, "dis_1", grs_op_Const, mode_ANY, 1);
+    /* TODO typeof(ld_1) = Load \ []*/
+    ext_grs_node_t *n_ld_1 = ext_grs_act_add_node(pattern, "ld_1", grs_op_Load, mode_ANY, 2);
+    /* TODO typeof(a_1) = Add \ []*/
+    ext_grs_node_t *n_a_1 = ext_grs_act_add_node(pattern, "a_1", grs_op_Add, mode_ANY, 3);
+    /* TODO typeof(a_2) = Add \ []*/
+    ext_grs_node_t *n_a_2 = ext_grs_act_add_node(pattern, "a_2", grs_op_Add, mode_ANY, 4);
+    /* TODO typeof(addr) = Phi \ []*/
+    ext_grs_node_t *n_addr = ext_grs_act_add_node(pattern, "addr", grs_op_Phi, mode_ANY, 5);
+    /* TODO typeof(dis_2) = Const \ []*/
+    ext_grs_node_t *n_dis_2 = ext_grs_act_add_node(pattern, "dis_2", grs_op_Const, mode_ANY, 6);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 7);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_a_2, n_ld_2, 0);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_addr, n_a_2, 1);
+    ext_grs_edge_t *e__edge7 = ext_grs_act_add_edge(pattern, "_edge7", ext_grs_NO_EDGE_POS, n_bb, n_ld_2, 2);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_dis_1, n_a_1, 3);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_a_1, n_ld_1, 4);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_bb, n_ld_1, 5);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_addr, n_a_1, 6);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_dis_2, n_a_2, 7);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* V2LD_d */
+
+
+/* functions for evaluation of conditions of action V2ST_a */
+
+/* functions for building the pattern of action V2ST_a */
+static _inline ext_grs_action_t *grs_action_V2ST_a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "V2ST_a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(st_2) = Store \ []*/
+    ext_grs_node_t *n_st_2 = ext_grs_act_add_node(pattern, "st_2", grs_op_Store, mode_ANY, 0);
+    /* TODO typeof(vpi_2) = V2pi_2 \ []*/
+    ext_grs_node_t *n_vpi_2 = ext_grs_act_add_node(pattern, "vpi_2", grs_op_V2pi_2, mode_ANY, 1);
+    /* TODO typeof(st_1) = Store \ []*/
+    ext_grs_node_t *n_st_1 = ext_grs_act_add_node(pattern, "st_1", grs_op_Store, mode_ANY, 2);
+    /* TODO typeof(vpi_1) = V2pi_1 \ []*/
+    ext_grs_node_t *n_vpi_1 = ext_grs_act_add_node(pattern, "vpi_1", grs_op_V2pi_1, mode_ANY, 3);
+    /* TODO typeof(a) = Vector \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_Vector, mode_ANY, 4);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_a, n_vpi_2, 0);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_a, n_vpi_1, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_vpi_1, n_st_1, 2);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_vpi_2, n_st_2, 3);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* V2ST_a */
+
+
+/* functions for evaluation of conditions of action V2SUB_a */
+
+/* functions for building the pattern of action V2SUB_a */
+static _inline ext_grs_action_t *grs_action_V2SUB_a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "V2SUB_a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(p1_1) = Proj \ []*/
+    ext_grs_node_t *n_p1_1 = ext_grs_act_add_node(pattern, "p1_1", grs_op_Proj, mode_ANY, 0);
+    /* TODO typeof(vpi1_1) = V2pi_1 \ []*/
+    ext_grs_node_t *n_vpi1_1 = ext_grs_act_add_node(pattern, "vpi1_1", grs_op_V2pi_1, mode_ANY, 1);
+    /* TODO typeof(p2_1) = Proj \ []*/
+    ext_grs_node_t *n_p2_1 = ext_grs_act_add_node(pattern, "p2_1", grs_op_Proj, mode_ANY, 2);
+    /* TODO typeof(s_1) = Sub \ []*/
+    ext_grs_node_t *n_s_1 = ext_grs_act_add_node(pattern, "s_1", grs_op_Sub, mode_ANY, 3);
+    /* TODO typeof(vpi2_2) = V2pi_2 \ []*/
+    ext_grs_node_t *n_vpi2_2 = ext_grs_act_add_node(pattern, "vpi2_2", grs_op_V2pi_2, mode_ANY, 4);
+    /* TODO typeof(p2_2) = Proj \ []*/
+    ext_grs_node_t *n_p2_2 = ext_grs_act_add_node(pattern, "p2_2", grs_op_Proj, mode_ANY, 5);
+    /* TODO typeof(s_2) = Sub \ []*/
+    ext_grs_node_t *n_s_2 = ext_grs_act_add_node(pattern, "s_2", grs_op_Sub, mode_ANY, 6);
+    /* TODO typeof(vpi2_1) = V2pi_1 \ []*/
+    ext_grs_node_t *n_vpi2_1 = ext_grs_act_add_node(pattern, "vpi2_1", grs_op_V2pi_1, mode_ANY, 7);
+    /* TODO typeof(b) = Vector \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_Vector, mode_ANY, 8);
+    /* TODO typeof(a) = Vector \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_Vector, mode_ANY, 9);
+    /* TODO typeof(vpi1_2) = V2pi_2 \ []*/
+    ext_grs_node_t *n_vpi1_2 = ext_grs_act_add_node(pattern, "vpi1_2", grs_op_V2pi_2, mode_ANY, 10);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 11);
+    /* TODO typeof(p1_2) = Proj \ []*/
+    ext_grs_node_t *n_p1_2 = ext_grs_act_add_node(pattern, "p1_2", grs_op_Proj, mode_ANY, 12);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_p2_1, n_s_1, 0);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_a, n_vpi1_1, 1);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_a, n_vpi1_2, 2);
+    ext_grs_edge_t *e__edge11 = ext_grs_act_add_edge(pattern, "_edge11", ext_grs_NO_EDGE_POS, n_b, n_vpi2_2, 3);
+    ext_grs_edge_t *e__edge12 = ext_grs_act_add_edge(pattern, "_edge12", ext_grs_NO_EDGE_POS, n_bb, n_s_1, 4);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_vpi2_1, n_p2_1, 5);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_b, n_vpi2_1, 6);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_vpi1_1, n_p1_1, 7);
+    ext_grs_edge_t *e__edge7 = ext_grs_act_add_edge(pattern, "_edge7", ext_grs_NO_EDGE_POS, n_vpi1_2, n_p1_2, 8);
+    ext_grs_edge_t *e__edge13 = ext_grs_act_add_edge(pattern, "_edge13", ext_grs_NO_EDGE_POS, n_bb, n_s_2, 9);
+    ext_grs_edge_t *e__edge8 = ext_grs_act_add_edge(pattern, "_edge8", ext_grs_NO_EDGE_POS, n_p1_2, n_s_2, 10);
+    ext_grs_edge_t *e__edge10 = ext_grs_act_add_edge(pattern, "_edge10", ext_grs_NO_EDGE_POS, n_vpi2_2, n_p2_2, 11);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_p1_1, n_s_1, 12);
+    ext_grs_edge_t *e__edge9 = ext_grs_act_add_edge(pattern, "_edge9", ext_grs_NO_EDGE_POS, n_p2_2, n_s_2, 13);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* V2SUB_a */
+
+
+/* functions for evaluation of conditions of action dead_Block */
+
+/* functions for building the pattern of action dead_Block */
+static _inline ext_grs_action_t *grs_action_dead_Block_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "dead_Block");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b1) = Block \ []*/
+    ext_grs_node_t *n_b1 = ext_grs_act_add_node(pattern, "b1", grs_op_Block, mode_ANY, 0);
+    /* TODO typeof(ir2) = IR_node \ []*/
+    ext_grs_node_t *n_ir2 = ext_grs_act_add_node(pattern, "ir2", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(b2) = Block \ []*/
+    ext_grs_node_t *n_b2 = ext_grs_act_add_node(pattern, "b2", grs_op_Block, mode_ANY, 2);
+    /* TODO typeof(ir1) = IR_node \ []*/
+    ext_grs_node_t *n_ir1 = ext_grs_act_add_node(pattern, "ir1", grs_op_IR_node, mode_ANY, 3);
+    /* TODO typeof(b) = Block \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_Block, mode_ANY, 4);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_cf3 = ext_grs_act_add_edge(pattern, "cf3", ext_grs_NO_EDGE_POS, n_b1, n_ir1, 0);
+    ext_grs_edge_t *e_cf1 = ext_grs_act_add_edge(pattern, "cf1", ext_grs_NO_EDGE_POS, n_ir1, n_b, 1);
+    ext_grs_edge_t *e_cf4 = ext_grs_act_add_edge(pattern, "cf4", ext_grs_NO_EDGE_POS, n_b2, n_ir2, 2);
+    ext_grs_edge_t *e_cf2 = ext_grs_act_add_edge(pattern, "cf2", ext_grs_NO_EDGE_POS, n_ir2, n_b, 3);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_48) = Block \ []*/
+      ext_grs_node_t *n_b1_48 = ext_grs_act_add_related_node(pattern, "b1_48", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(phi) = Phi \ []*/
+      ext_grs_node_t *n_phi = ext_grs_act_add_node(pattern, "phi", grs_op_Phi, mode_ANY, 5);
+      /* TODO typeof(ir2_49) = IR_node \ []*/
+      ext_grs_node_t *n_ir2_49 = ext_grs_act_add_related_node(pattern, "ir2_49", grs_op_IR_node, mode_ANY, 1, n_ir2);
+      /* TODO typeof(b2_50) = Block \ []*/
+      ext_grs_node_t *n_b2_50 = ext_grs_act_add_related_node(pattern, "b2_50", grs_op_Block, mode_ANY, 2, n_b2);
+      /* TODO typeof(ir1_51) = IR_node \ []*/
+      ext_grs_node_t *n_ir1_51 = ext_grs_act_add_related_node(pattern, "ir1_51", grs_op_IR_node, mode_ANY, 3, n_ir1);
+      /* TODO typeof(b_52) = Block \ []*/
+      ext_grs_node_t *n_b_52 = ext_grs_act_add_related_node(pattern, "b_52", grs_op_Block, mode_ANY, 4, n_b);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf3_53 = ext_grs_act_add_related_edge(pattern, "cf3_53", ext_grs_NO_EDGE_POS, n_b1_48, n_ir1_51, 0, e_cf3);
+      ext_grs_edge_t *e_cf1_54 = ext_grs_act_add_related_edge(pattern, "cf1_54", ext_grs_NO_EDGE_POS, n_ir1_51, n_b_52, 1, e_cf1);
+      ext_grs_edge_t *e_cf4_55 = ext_grs_act_add_related_edge(pattern, "cf4_55", ext_grs_NO_EDGE_POS, n_b2_50, n_ir2_49, 2, e_cf4);
+      ext_grs_edge_t *e_cf2_56 = ext_grs_act_add_related_edge(pattern, "cf2_56", ext_grs_NO_EDGE_POS, n_ir2_49, n_b_52, 3, e_cf2);
+      ext_grs_edge_t *e_cf5_57 = ext_grs_act_add_edge(pattern, "cf5_57", ext_grs_NO_EDGE_POS, n_b_52, n_phi, 4);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_58) = Block \ []*/
+      ext_grs_node_t *n_b1_58 = ext_grs_act_add_related_node(pattern, "b1_58", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(ir2_59) = IR_node \ []*/
+      ext_grs_node_t *n_ir2_59 = ext_grs_act_add_related_node(pattern, "ir2_59", grs_op_IR_node, mode_ANY, 1, n_ir2);
+      /* TODO typeof(b2_60) = Block \ []*/
+      ext_grs_node_t *n_b2_60 = ext_grs_act_add_related_node(pattern, "b2_60", grs_op_Block, mode_ANY, 2, n_b2);
+      /* TODO typeof(ir1_61) = IR_node \ []*/
+      ext_grs_node_t *n_ir1_61 = ext_grs_act_add_related_node(pattern, "ir1_61", grs_op_IR_node, mode_ANY, 3, n_ir1);
+      /* TODO typeof(b_62) = Block \ []*/
+      ext_grs_node_t *n_b_62 = ext_grs_act_add_related_node(pattern, "b_62", grs_op_Block, mode_ANY, 4, n_b);
+      /* TODO typeof(b3) = Block \ []*/
+      ext_grs_node_t *n_b3 = ext_grs_act_add_node(pattern, "b3", grs_op_Block, mode_ANY, 6);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf3_63 = ext_grs_act_add_related_edge(pattern, "cf3_63", ext_grs_NO_EDGE_POS, n_b1_58, n_ir1_61, 0, e_cf3);
+      ext_grs_edge_t *e_cf1_64 = ext_grs_act_add_related_edge(pattern, "cf1_64", ext_grs_NO_EDGE_POS, n_ir1_61, n_b_62, 1, e_cf1);
+      ext_grs_edge_t *e_cf6_65 = ext_grs_act_add_edge(pattern, "cf6_65", ext_grs_NO_EDGE_POS, n_b1_58, n_b3, 5);
+      ext_grs_edge_t *e_cf4_66 = ext_grs_act_add_related_edge(pattern, "cf4_66", ext_grs_NO_EDGE_POS, n_b2_60, n_ir2_59, 2, e_cf4);
+      ext_grs_edge_t *e_cf2_67 = ext_grs_act_add_related_edge(pattern, "cf2_67", ext_grs_NO_EDGE_POS, n_ir2_59, n_b_62, 3, e_cf2);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+    { /* NAC 2  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_68) = Block \ []*/
+      ext_grs_node_t *n_b1_68 = ext_grs_act_add_related_node(pattern, "b1_68", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(ir2_69) = IR_node \ []*/
+      ext_grs_node_t *n_ir2_69 = ext_grs_act_add_related_node(pattern, "ir2_69", grs_op_IR_node, mode_ANY, 1, n_ir2);
+      /* TODO typeof(ir3) = IR_node \ []*/
+      ext_grs_node_t *n_ir3 = ext_grs_act_add_node(pattern, "ir3", grs_op_IR_node, mode_ANY, 7);
+      /* TODO typeof(b2_70) = Block \ []*/
+      ext_grs_node_t *n_b2_70 = ext_grs_act_add_related_node(pattern, "b2_70", grs_op_Block, mode_ANY, 2, n_b2);
+      /* TODO typeof(ir1_71) = IR_node \ []*/
+      ext_grs_node_t *n_ir1_71 = ext_grs_act_add_related_node(pattern, "ir1_71", grs_op_IR_node, mode_ANY, 3, n_ir1);
+      /* TODO typeof(b_72) = Block \ []*/
+      ext_grs_node_t *n_b_72 = ext_grs_act_add_related_node(pattern, "b_72", grs_op_Block, mode_ANY, 4, n_b);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf3_73 = ext_grs_act_add_related_edge(pattern, "cf3_73", ext_grs_NO_EDGE_POS, n_b1_68, n_ir1_71, 0, e_cf3);
+      ext_grs_edge_t *e_cf1_74 = ext_grs_act_add_related_edge(pattern, "cf1_74", ext_grs_NO_EDGE_POS, n_ir1_71, n_b_72, 1, e_cf1);
+      ext_grs_edge_t *e_cf4_75 = ext_grs_act_add_related_edge(pattern, "cf4_75", ext_grs_NO_EDGE_POS, n_b2_70, n_ir2_69, 2, e_cf4);
+      ext_grs_edge_t *e_cf2_76 = ext_grs_act_add_related_edge(pattern, "cf2_76", ext_grs_NO_EDGE_POS, n_ir2_69, n_b_72, 3, e_cf2);
+      ext_grs_edge_t *e_cf7_77 = ext_grs_act_add_edge(pattern, "cf7_77", ext_grs_NO_EDGE_POS, n_b1_68, n_ir3, 6);
+
+      /* The conditions of the pattern */
+    } /* NAC 2  */
+
+    { /* NAC 3  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_78) = Block \ []*/
+      ext_grs_node_t *n_b1_78 = ext_grs_act_add_related_node(pattern, "b1_78", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(ir2_79) = IR_node \ []*/
+      ext_grs_node_t *n_ir2_79 = ext_grs_act_add_related_node(pattern, "ir2_79", grs_op_IR_node, mode_ANY, 1, n_ir2);
+      /* TODO typeof(start) = Start \ []*/
+      ext_grs_node_t *n_start = ext_grs_act_add_node(pattern, "start", grs_op_Start, mode_ANY, 8);
+      /* TODO typeof(b2_80) = Block \ []*/
+      ext_grs_node_t *n_b2_80 = ext_grs_act_add_related_node(pattern, "b2_80", grs_op_Block, mode_ANY, 2, n_b2);
+      /* TODO typeof(ir1_81) = IR_node \ []*/
+      ext_grs_node_t *n_ir1_81 = ext_grs_act_add_related_node(pattern, "ir1_81", grs_op_IR_node, mode_ANY, 3, n_ir1);
+      /* TODO typeof(b_82) = Block \ []*/
+      ext_grs_node_t *n_b_82 = ext_grs_act_add_related_node(pattern, "b_82", grs_op_Block, mode_ANY, 4, n_b);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf3_83 = ext_grs_act_add_related_edge(pattern, "cf3_83", ext_grs_NO_EDGE_POS, n_b1_78, n_ir1_81, 0, e_cf3);
+      ext_grs_edge_t *e_cf1_84 = ext_grs_act_add_related_edge(pattern, "cf1_84", ext_grs_NO_EDGE_POS, n_ir1_81, n_b_82, 1, e_cf1);
+      ext_grs_edge_t *e_cf8_85 = ext_grs_act_add_edge(pattern, "cf8_85", ext_grs_NO_EDGE_POS, n_b1_78, n_start, 7);
+      ext_grs_edge_t *e_cf4_86 = ext_grs_act_add_related_edge(pattern, "cf4_86", ext_grs_NO_EDGE_POS, n_b2_80, n_ir2_79, 2, e_cf4);
+      ext_grs_edge_t *e_cf2_87 = ext_grs_act_add_related_edge(pattern, "cf2_87", ext_grs_NO_EDGE_POS, n_ir2_79, n_b_82, 3, e_cf2);
+
+      /* The conditions of the pattern */
+    } /* NAC 3  */
+
+    { /* NAC 4  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_88) = Block \ []*/
+      ext_grs_node_t *n_b1_88 = ext_grs_act_add_related_node(pattern, "b1_88", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(ir2_89) = IR_node \ []*/
+      ext_grs_node_t *n_ir2_89 = ext_grs_act_add_related_node(pattern, "ir2_89", grs_op_IR_node, mode_ANY, 1, n_ir2);
+      /* TODO typeof(end) = End \ []*/
+      ext_grs_node_t *n_end = ext_grs_act_add_node(pattern, "end", grs_op_End, mode_ANY, 9);
+      /* TODO typeof(b2_90) = Block \ []*/
+      ext_grs_node_t *n_b2_90 = ext_grs_act_add_related_node(pattern, "b2_90", grs_op_Block, mode_ANY, 2, n_b2);
+      /* TODO typeof(ir1_91) = IR_node \ []*/
+      ext_grs_node_t *n_ir1_91 = ext_grs_act_add_related_node(pattern, "ir1_91", grs_op_IR_node, mode_ANY, 3, n_ir1);
+      /* TODO typeof(b_92) = Block \ []*/
+      ext_grs_node_t *n_b_92 = ext_grs_act_add_related_node(pattern, "b_92", grs_op_Block, mode_ANY, 4, n_b);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf3_93 = ext_grs_act_add_related_edge(pattern, "cf3_93", ext_grs_NO_EDGE_POS, n_b1_88, n_ir1_91, 0, e_cf3);
+      ext_grs_edge_t *e_cf1_94 = ext_grs_act_add_related_edge(pattern, "cf1_94", ext_grs_NO_EDGE_POS, n_ir1_91, n_b_92, 1, e_cf1);
+      ext_grs_edge_t *e_cf8_95 = ext_grs_act_add_edge(pattern, "cf8_95", ext_grs_NO_EDGE_POS, n_b_92, n_end, 8);
+      ext_grs_edge_t *e_cf4_96 = ext_grs_act_add_related_edge(pattern, "cf4_96", ext_grs_NO_EDGE_POS, n_b2_90, n_ir2_89, 2, e_cf4);
+      ext_grs_edge_t *e_cf2_97 = ext_grs_act_add_related_edge(pattern, "cf2_97", ext_grs_NO_EDGE_POS, n_ir2_89, n_b_92, 3, e_cf2);
+
+      /* The conditions of the pattern */
+    } /* NAC 4  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* dead_Block */
+
+
+/* functions for evaluation of conditions of action dead_Block_unify */
+
+/* functions for building the pattern of action dead_Block_unify */
+static _inline ext_grs_action_t *grs_action_dead_Block_unify_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "dead_Block_unify");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b1) = Block \ []*/
+    ext_grs_node_t *n_b1 = ext_grs_act_add_node(pattern, "b1", grs_op_Block, mode_ANY, 0);
+    /* TODO typeof(ir1) = IR_node \ []*/
+    ext_grs_node_t *n_ir1 = ext_grs_act_add_node(pattern, "ir1", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(b) = Block \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_Block, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_cf3 = ext_grs_act_add_edge(pattern, "cf3", ext_grs_NO_EDGE_POS, n_b1, n_ir1, 0);
+    ext_grs_edge_t *e_cf1 = ext_grs_act_add_edge(pattern, "cf1", ext_grs_NO_EDGE_POS, n_ir1, n_b, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_98) = Block \ []*/
+      ext_grs_node_t *n_b1_98 = ext_grs_act_add_related_node(pattern, "b1_98", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(ir2) = IR_node \ []*/
+      ext_grs_node_t *n_ir2 = ext_grs_act_add_node(pattern, "ir2", grs_op_IR_node, mode_ANY, 3);
+      /* TODO typeof(b2) = Block \ []*/
+      ext_grs_node_t *n_b2 = ext_grs_act_add_node(pattern, "b2", grs_op_Block, mode_ANY, 4);
+      /* TODO typeof(ir1_99) = IR_node \ []*/
+      ext_grs_node_t *n_ir1_99 = ext_grs_act_add_related_node(pattern, "ir1_99", grs_op_IR_node, mode_ANY, 1, n_ir1);
+      /* TODO typeof(b_100) = Block \ []*/
+      ext_grs_node_t *n_b_100 = ext_grs_act_add_related_node(pattern, "b_100", grs_op_Block, mode_ANY, 2, n_b);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf3_101 = ext_grs_act_add_related_edge(pattern, "cf3_101", ext_grs_NO_EDGE_POS, n_b1_98, n_ir1_99, 0, e_cf3);
+      ext_grs_edge_t *e_cf1_102 = ext_grs_act_add_related_edge(pattern, "cf1_102", ext_grs_NO_EDGE_POS, n_ir1_99, n_b_100, 1, e_cf1);
+      ext_grs_edge_t *e_cf6_103 = ext_grs_act_add_edge(pattern, "cf6_103", ext_grs_NO_EDGE_POS, n_ir2, n_b_100, 2);
+      ext_grs_edge_t *e_cf9_104 = ext_grs_act_add_edge(pattern, "cf9_104", ext_grs_NO_EDGE_POS, n_b2, n_ir2, 3);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_105) = Block \ []*/
+      ext_grs_node_t *n_b1_105 = ext_grs_act_add_related_node(pattern, "b1_105", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(ir3) = IR_node \ []*/
+      ext_grs_node_t *n_ir3 = ext_grs_act_add_node(pattern, "ir3", grs_op_IR_node, mode_ANY, 5);
+      /* TODO typeof(ir1_106) = IR_node \ []*/
+      ext_grs_node_t *n_ir1_106 = ext_grs_act_add_related_node(pattern, "ir1_106", grs_op_IR_node, mode_ANY, 1, n_ir1);
+      /* TODO typeof(b_107) = Block \ []*/
+      ext_grs_node_t *n_b_107 = ext_grs_act_add_related_node(pattern, "b_107", grs_op_Block, mode_ANY, 2, n_b);
+      /* TODO typeof(b3) = Block \ []*/
+      ext_grs_node_t *n_b3 = ext_grs_act_add_node(pattern, "b3", grs_op_Block, mode_ANY, 6);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf3_108 = ext_grs_act_add_related_edge(pattern, "cf3_108", ext_grs_NO_EDGE_POS, n_b1_105, n_ir1_106, 0, e_cf3);
+      ext_grs_edge_t *e_cf1_109 = ext_grs_act_add_related_edge(pattern, "cf1_109", ext_grs_NO_EDGE_POS, n_ir1_106, n_b_107, 1, e_cf1);
+      ext_grs_edge_t *e_cf8_110 = ext_grs_act_add_edge(pattern, "cf8_110", ext_grs_NO_EDGE_POS, n_b1_105, n_ir3, 4);
+      ext_grs_edge_t *e_cf7_111 = ext_grs_act_add_edge(pattern, "cf7_111", ext_grs_NO_EDGE_POS, n_ir3, n_b3, 5);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+    { /* NAC 2  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_112) = Block \ []*/
+      ext_grs_node_t *n_b1_112 = ext_grs_act_add_related_node(pattern, "b1_112", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(start) = Start \ []*/
+      ext_grs_node_t *n_start = ext_grs_act_add_node(pattern, "start", grs_op_Start, mode_ANY, 7);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf8_113 = ext_grs_act_add_edge(pattern, "cf8_113", ext_grs_NO_EDGE_POS, n_b1_112, n_start, 6);
+
+      /* The conditions of the pattern */
+    } /* NAC 2  */
+
+    { /* NAC 3  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(end) = End \ []*/
+      ext_grs_node_t *n_end = ext_grs_act_add_node(pattern, "end", grs_op_End, mode_ANY, 8);
+      /* TODO typeof(b_114) = Block \ []*/
+      ext_grs_node_t *n_b_114 = ext_grs_act_add_related_node(pattern, "b_114", grs_op_Block, mode_ANY, 2, n_b);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf8_115 = ext_grs_act_add_edge(pattern, "cf8_115", ext_grs_NO_EDGE_POS, n_b_114, n_end, 7);
+
+      /* The conditions of the pattern */
+    } /* NAC 3  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* dead_Block_unify */
+
+
+/* functions for evaluation of conditions of action dead_Block_unify2 */
+
+/* functions for building the pattern of action dead_Block_unify2 */
+static _inline ext_grs_action_t *grs_action_dead_Block_unify2_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "dead_Block_unify2");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(b1) = Block \ []*/
+    ext_grs_node_t *n_b1 = ext_grs_act_add_node(pattern, "b1", grs_op_Block, mode_ANY, 0);
+    /* TODO typeof(ir1) = IR_node \ []*/
+    ext_grs_node_t *n_ir1 = ext_grs_act_add_node(pattern, "ir1", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(b) = Block \ []*/
+    ext_grs_node_t *n_b = ext_grs_act_add_node(pattern, "b", grs_op_Block, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_cf3 = ext_grs_act_add_edge(pattern, "cf3", ext_grs_NO_EDGE_POS, n_b1, n_ir1, 0);
+    ext_grs_edge_t *e_cf1 = ext_grs_act_add_edge(pattern, "cf1", ext_grs_NO_EDGE_POS, n_ir1, n_b, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(b1_116) = Block \ []*/
+      ext_grs_node_t *n_b1_116 = ext_grs_act_add_related_node(pattern, "b1_116", grs_op_Block, mode_ANY, 0, n_b1);
+      /* TODO typeof(start) = Start \ []*/
+      ext_grs_node_t *n_start = ext_grs_act_add_node(pattern, "start", grs_op_Start, mode_ANY, 3);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf8_117 = ext_grs_act_add_edge(pattern, "cf8_117", ext_grs_NO_EDGE_POS, n_b1_116, n_start, 2);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(end) = End \ []*/
+      ext_grs_node_t *n_end = ext_grs_act_add_node(pattern, "end", grs_op_End, mode_ANY, 4);
+      /* TODO typeof(b_118) = Block \ []*/
+      ext_grs_node_t *n_b_118 = ext_grs_act_add_related_node(pattern, "b_118", grs_op_Block, mode_ANY, 2, n_b);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_cf8_119 = ext_grs_act_add_edge(pattern, "cf8_119", ext_grs_NO_EDGE_POS, n_b_118, n_end, 3);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* dead_Block_unify2 */
+
+
+/* functions for evaluation of conditions of action dead_Load */
+static int grs_cond_func_11449(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+static int grs_cond_func_11452(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == "M";
+}
+
+/* functions for building the pattern of action dead_Load */
+static _inline ext_grs_action_t *grs_action_dead_Load_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "dead_Load");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+/* mode edge: edge hm2*/
+    /* TODO typeof(proj_m) = Proj \ []*/
+    ext_grs_node_t *n_proj_m = ext_grs_act_add_node(pattern, "proj_m", grs_op_Proj, mode_ANY, 0);
+    /* TODO typeof(pred_m) = IR_node \ []*/
+    ext_grs_node_t *n_pred_m = ext_grs_act_add_node(pattern, "pred_m", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(load) = Load \ []*/
+    ext_grs_node_t *n_load = ext_grs_act_add_node(pattern, "load", grs_op_Load, mode_ANY, 2);
+    /* TODO typeof(mode_m) = Mode \ []*/
+    ext_grs_node_t *n_mode_m = ext_grs_act_add_node(pattern, "mode_m", grs_op_Mode, mode_ANY, 3);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_pred_m, n_load, 0);
+    ext_grs_edge_t *e_hm2 = ext_grs_act_add_edge(pattern, "hm2", ext_grs_NO_EDGE_POS, n_mode_m, n_proj_m, 1);
+    ext_grs_edge_t *e_e = ext_grs_act_add_edge(pattern, "e", ext_grs_NO_EDGE_POS, n_load, n_proj_m, 2);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_load};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_11449, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_mode_m};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_11452, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(proj_m_120) = Proj \ []*/
+      ext_grs_node_t *n_proj_m_120 = ext_grs_act_add_related_node(pattern, "proj_m_120", grs_op_Proj, mode_ANY, 0, n_proj_m);
+      /* TODO typeof(load_121) = Load \ []*/
+      ext_grs_node_t *n_load_121 = ext_grs_act_add_related_node(pattern, "load_121", grs_op_Load, mode_ANY, 2, n_load);
+      /* TODO typeof(x) = IR_node \ []*/
+      ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 4);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_122 = ext_grs_act_add_edge(pattern, "_edge0_122", ext_grs_NO_EDGE_POS, n_load_121, n_x, 3);
+      ext_grs_edge_t *e_e_123 = ext_grs_act_add_related_edge(pattern, "e_123", ext_grs_NO_EDGE_POS, n_load_121, n_proj_m_120, 2, e_e);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* dead_Load */
+
+
+/* functions for evaluation of conditions of action dead_Ordinary */
+
+/* functions for building the pattern of action dead_Ordinary */
+static _inline ext_grs_action_t *grs_action_dead_Ordinary_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "dead_Ordinary");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(a) = Ordinary \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_Ordinary, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(x) = IR_node \ []*/
+      ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 1);
+      /* TODO typeof(a_124) = Ordinary \ []*/
+      ext_grs_node_t *n_a_124 = ext_grs_act_add_related_node(pattern, "a_124", grs_op_Ordinary, mode_ANY, 0, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_125 = ext_grs_act_add_edge(pattern, "_edge0_125", ext_grs_NO_EDGE_POS, n_a_124, n_x, 0);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(y) = IR_node \ []*/
+      ext_grs_node_t *n_y = ext_grs_act_add_node(pattern, "y", grs_op_IR_node, mode_ANY, 2);
+      /* TODO typeof(a_126) = Ordinary \ []*/
+      ext_grs_node_t *n_a_126 = ext_grs_act_add_related_node(pattern, "a_126", grs_op_Ordinary, mode_ANY, 0, n_a);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_127 = ext_grs_act_add_edge(pattern, "_edge0_127", ext_grs_NO_EDGE_POS, n_y, n_a_126, 1);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* dead_Ordinary */
+
+
+/* functions for evaluation of conditions of action dead_Proj_Load_Proj */
+static int grs_cond_func_11398(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == "M";
+}
+
+/* functions for building the pattern of action dead_Proj_Load_Proj */
+static _inline ext_grs_action_t *grs_action_dead_Proj_Load_Proj_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "dead_Proj_Load_Proj");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+/* mode edge: edge hm2*/
+    /* TODO typeof(after_prM) = Proj \ []*/
+    ext_grs_node_t *n_after_prM = ext_grs_act_add_node(pattern, "after_prM", grs_op_Proj, mode_ANY, 0);
+    /* TODO typeof(m_mode) = Mode \ []*/
+    ext_grs_node_t *n_m_mode = ext_grs_act_add_node(pattern, "m_mode", grs_op_Mode, mode_ANY, 1);
+/* mode edge: edge hm1*/
+    /* TODO typeof(before_prM) = Proj \ []*/
+    ext_grs_node_t *n_before_prM = ext_grs_act_add_node(pattern, "before_prM", grs_op_Proj, mode_ANY, 2);
+    /* TODO typeof(load) = Load \ []*/
+    ext_grs_node_t *n_load = ext_grs_act_add_node(pattern, "load", grs_op_Load, mode_ANY, 3);
+    /* TODO typeof(first) = IR_node \ []*/
+    ext_grs_node_t *n_first = ext_grs_act_add_node(pattern, "first", grs_op_IR_node, mode_ANY, 4);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_m1 = ext_grs_act_add_edge(pattern, "m1", ext_grs_NO_EDGE_POS, n_before_prM, n_load, 0);
+    ext_grs_edge_t *e_df1 = ext_grs_act_add_edge(pattern, "df1", ext_grs_NO_EDGE_POS, n_load, n_after_prM, 1);
+    ext_grs_edge_t *e_hm2 = ext_grs_act_add_edge(pattern, "hm2", ext_grs_NO_EDGE_POS, n_m_mode, n_after_prM, 2);
+    ext_grs_edge_t *e_df2 = ext_grs_act_add_edge(pattern, "df2", ext_grs_NO_EDGE_POS, n_first, n_before_prM, 3);
+    ext_grs_edge_t *e_hm1 = ext_grs_act_add_edge(pattern, "hm1", ext_grs_NO_EDGE_POS, n_m_mode, n_before_prM, 4);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_m_mode};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_11398, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(after_prM_128) = Proj \ []*/
+      ext_grs_node_t *n_after_prM_128 = ext_grs_act_add_related_node(pattern, "after_prM_128", grs_op_Proj, mode_ANY, 0, n_after_prM);
+      /* TODO typeof(load_129) = Load \ []*/
+      ext_grs_node_t *n_load_129 = ext_grs_act_add_related_node(pattern, "load_129", grs_op_Load, mode_ANY, 3, n_load);
+      /* TODO typeof(x) = IR_node \ []*/
+      ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 5);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e_df1_130 = ext_grs_act_add_related_edge(pattern, "df1_130", ext_grs_NO_EDGE_POS, n_load_129, n_after_prM_128, 1, e_df1);
+      ext_grs_edge_t *e__edge0_131 = ext_grs_act_add_edge(pattern, "_edge0_131", ext_grs_NO_EDGE_POS, n_load_129, n_x, 5);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* dead_Proj_Load_Proj */
+
+
+/* functions for evaluation of conditions of action dead_double_mem */
+
+/* functions for building the pattern of action dead_double_mem */
+static _inline ext_grs_action_t *grs_action_dead_double_mem_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "dead_double_mem");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(ir2) = IR_node \ []*/
+    ext_grs_node_t *n_ir2 = ext_grs_act_add_node(pattern, "ir2", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(ir1) = IR_node \ []*/
+    ext_grs_node_t *n_ir1 = ext_grs_act_add_node(pattern, "ir1", grs_op_IR_node, mode_ANY, 1);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_mem2 = ext_grs_act_add_edge(pattern, "mem2", ext_grs_NO_EDGE_POS, n_ir2, n_ir1, 0);
+    ext_grs_edge_t *e_mem1 = ext_grs_act_add_edge(pattern, "mem1", ext_grs_NO_EDGE_POS, n_ir2, n_ir1, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* dead_double_mem */
+
+
+/* functions for evaluation of conditions of action elim_AddSub */
+
+/* functions for building the pattern of action elim_AddSub */
+static _inline ext_grs_action_t *grs_action_elim_AddSub_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "elim_AddSub");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(y) = IR_node \ []*/
+    ext_grs_node_t *n_y = ext_grs_act_add_node(pattern, "y", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(s) = Sub \ []*/
+    ext_grs_node_t *n_s = ext_grs_act_add_node(pattern, "s", grs_op_Sub, mode_ANY, 1);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 2);
+    /* TODO typeof(a) = Add \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_Add, mode_ANY, 3);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_y, n_s, 0);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_y, n_a, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_a, 2);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_a, n_s, 3);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* elim_AddSub */
+
+
+/* functions for evaluation of conditions of action elim_SubAdd */
+
+/* functions for building the pattern of action elim_SubAdd */
+static _inline ext_grs_action_t *grs_action_elim_SubAdd_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "elim_SubAdd");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(y) = IR_node \ []*/
+    ext_grs_node_t *n_y = ext_grs_act_add_node(pattern, "y", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(s) = Sub \ []*/
+    ext_grs_node_t *n_s = ext_grs_act_add_node(pattern, "s", grs_op_Sub, mode_ANY, 1);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 2);
+    /* TODO typeof(a) = Add \ []*/
+    ext_grs_node_t *n_a = ext_grs_act_add_node(pattern, "a", grs_op_Add, mode_ANY, 3);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_y, n_a, 0);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_y, n_s, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_s, 2);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_s, n_a, 3);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* elim_SubAdd */
+
+
+/* functions for evaluation of conditions of action ids_copy_cf */
+
+/* functions for building the pattern of action ids_copy_cf */
+static _inline ext_grs_action_t *grs_action_ids_copy_cf_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "ids_copy_cf");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(id) = Id \ []*/
+    ext_grs_node_t *n_id = ext_grs_act_add_node(pattern, "id", grs_op_Id, mode_ANY, 0);
+    /* TODO typeof(succ) = IR_node \ []*/
+    ext_grs_node_t *n_succ = ext_grs_act_add_node(pattern, "succ", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(pre) = IR_node \ []*/
+    ext_grs_node_t *n_pre = ext_grs_act_add_node(pattern, "pre", grs_op_IR_node, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_succE = ext_grs_act_add_edge(pattern, "succE", ext_grs_NO_EDGE_POS, n_id, n_succ, 0);
+    ext_grs_edge_t *e_preE = ext_grs_act_add_edge(pattern, "preE", ext_grs_NO_EDGE_POS, n_pre, n_id, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* ids_copy_cf */
+
+
+/* functions for evaluation of conditions of action ids_copy_df */
+
+/* functions for building the pattern of action ids_copy_df */
+static _inline ext_grs_action_t *grs_action_ids_copy_df_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "ids_copy_df");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(id) = Id \ []*/
+    ext_grs_node_t *n_id = ext_grs_act_add_node(pattern, "id", grs_op_Id, mode_ANY, 0);
+    /* TODO typeof(succ) = IR_node \ []*/
+    ext_grs_node_t *n_succ = ext_grs_act_add_node(pattern, "succ", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(pre) = IR_node \ []*/
+    ext_grs_node_t *n_pre = ext_grs_act_add_node(pattern, "pre", grs_op_IR_node, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_succE = ext_grs_act_add_edge(pattern, "succE", ext_grs_NO_EDGE_POS, n_id, n_succ, 0);
+    ext_grs_edge_t *e_preE = ext_grs_act_add_edge(pattern, "preE", ext_grs_NO_EDGE_POS, n_pre, n_id, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* ids_copy_df */
+
+
+/* functions for evaluation of conditions of action ids_copy_mem */
+
+/* functions for building the pattern of action ids_copy_mem */
+static _inline ext_grs_action_t *grs_action_ids_copy_mem_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "ids_copy_mem");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(id) = Id \ []*/
+    ext_grs_node_t *n_id = ext_grs_act_add_node(pattern, "id", grs_op_Id, mode_ANY, 0);
+    /* TODO typeof(succ) = IR_node \ [node type Block]*/
+    ext_grs_node_t *n_succ = ext_grs_act_add_node(pattern, "succ", grs_op_IR_node, mode_ANY, 1);
+    /* TODO typeof(pre) = IR_node \ [node type Block]*/
+    ext_grs_node_t *n_pre = ext_grs_act_add_node(pattern, "pre", grs_op_IR_node, mode_ANY, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_succE = ext_grs_act_add_edge(pattern, "succE", ext_grs_NO_EDGE_POS, n_id, n_succ, 0);
+    ext_grs_edge_t *e_preE = ext_grs_act_add_edge(pattern, "preE", ext_grs_NO_EDGE_POS, n_pre, n_id, 1);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* ids_copy_mem */
+
+
+/* functions for evaluation of conditions of action ids_remove */
+
+/* functions for building the pattern of action ids_remove */
+static _inline ext_grs_action_t *grs_action_ids_remove_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "ids_remove");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(id) = Id \ []*/
+    ext_grs_node_t *n_id = ext_grs_act_add_node(pattern, "id", grs_op_Id, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(id_132) = Id \ []*/
+      ext_grs_node_t *n_id_132 = ext_grs_act_add_related_node(pattern, "id_132", grs_op_Id, mode_ANY, 0, n_id);
+      /* TODO typeof(succ) = IR_node \ []*/
+      ext_grs_node_t *n_succ = ext_grs_act_add_node(pattern, "succ", grs_op_IR_node, mode_ANY, 1);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_133 = ext_grs_act_add_edge(pattern, "_edge0_133", ext_grs_NO_EDGE_POS, n_id_132, n_succ, 0);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* ids_remove */
+
+
+/* functions for evaluation of conditions of action mux_a */
+static int grs_cond_func_11133(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+static int grs_cond_func_11136(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 1;
+}
+static int grs_cond_func_11139(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ ==  0 /* TODO attr access */;
+}
+static int grs_cond_func_11142(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ ==  0 /* TODO attr access */;
+}
+
+/* functions for building the pattern of action mux_a */
+static _inline ext_grs_action_t *grs_action_mux_a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "mux_a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(cond) = Cond \ []*/
+    ext_grs_node_t *n_cond = ext_grs_act_add_node(pattern, "cond", grs_op_Cond, mode_ANY, 0);
+    /* TODO typeof(phi) = Phi \ []*/
+    ext_grs_node_t *n_phi = ext_grs_act_add_node(pattern, "phi", grs_op_Phi, mode_ANY, 1);
+    /* TODO typeof(bb1) = Block \ []*/
+    ext_grs_node_t *n_bb1 = ext_grs_act_add_node(pattern, "bb1", grs_op_Block, mode_ANY, 2);
+    /* TODO typeof(x2) = IR_node \ []*/
+    ext_grs_node_t *n_x2 = ext_grs_act_add_node(pattern, "x2", grs_op_IR_node, mode_ANY, 3);
+    /* TODO typeof(bb0) = Block \ []*/
+    ext_grs_node_t *n_bb0 = ext_grs_act_add_node(pattern, "bb0", grs_op_Block, mode_ANY, 4);
+    /* TODO typeof(mx) = Mode \ []*/
+    ext_grs_node_t *n_mx = ext_grs_act_add_node(pattern, "mx", grs_op_Mode, mode_ANY, 5);
+/* mode edge: edge $edge4*/
+    /* TODO typeof(px0) = Proj \ []*/
+    ext_grs_node_t *n_px0 = ext_grs_act_add_node(pattern, "px0", grs_op_Proj, mode_ANY, 6);
+    /* TODO typeof(jmp) = Jmp \ []*/
+    ext_grs_node_t *n_jmp = ext_grs_act_add_node(pattern, "jmp", grs_op_Jmp, mode_ANY, 7);
+    /* TODO typeof(pb) = Proj \ []*/
+    ext_grs_node_t *n_pb = ext_grs_act_add_node(pattern, "pb", grs_op_Proj, mode_ANY, 8);
+    /* TODO typeof(x1) = IR_node \ []*/
+    ext_grs_node_t *n_x1 = ext_grs_act_add_node(pattern, "x1", grs_op_IR_node, mode_ANY, 9);
+/* mode edge: edge $edge5*/
+    /* TODO typeof(px1) = Proj \ []*/
+    ext_grs_node_t *n_px1 = ext_grs_act_add_node(pattern, "px1", grs_op_Proj, mode_ANY, 10);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 11);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_bb, n_px1, 0);
+    ext_grs_edge_t *e_ephi2 = ext_grs_act_add_edge(pattern, "ephi2", ext_grs_NO_EDGE_POS, n_x2, n_phi, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_bb, n_pb, 2);
+    ext_grs_edge_t *e_ephibb2 = ext_grs_act_add_edge(pattern, "ephibb2", ext_grs_NO_EDGE_POS, n_px1, n_bb1, 3);
+    ext_grs_edge_t *e_ephi1 = ext_grs_act_add_edge(pattern, "ephi1", ext_grs_NO_EDGE_POS, n_x1, n_phi, 4);
+    ext_grs_edge_t *e__edge6 = ext_grs_act_add_edge(pattern, "_edge6", ext_grs_NO_EDGE_POS, n_bb0, n_jmp, 5);
+    ext_grs_edge_t *e__edge11 = ext_grs_act_add_edge(pattern, "_edge11", ext_grs_NO_EDGE_POS, n_pb, n_cond, 6);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_mx, n_px0, 7);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_mx, n_px1, 8);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_bb, n_cond, 9);
+    ext_grs_edge_t *e__edge7 = ext_grs_act_add_edge(pattern, "_edge7", ext_grs_NO_EDGE_POS, n_bb1, n_phi, 10);
+    ext_grs_edge_t *e__edge8 = ext_grs_act_add_edge(pattern, "_edge8", ext_grs_NO_EDGE_POS, n_px0, n_bb0, 11);
+    ext_grs_edge_t *e__edge10 = ext_grs_act_add_edge(pattern, "_edge10", ext_grs_NO_EDGE_POS, n_cond, n_px1, 12);
+    ext_grs_edge_t *e_ephibb1 = ext_grs_act_add_edge(pattern, "ephibb1", ext_grs_NO_EDGE_POS, n_jmp, n_bb1, 13);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_bb, n_px0, 14);
+    ext_grs_edge_t *e__edge9 = ext_grs_act_add_edge(pattern, "_edge9", ext_grs_NO_EDGE_POS, n_cond, n_px0, 15);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_px0};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_11133, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_px1};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_11136, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_ephi1, e_ephibb1};
+
+      ext_grs_act_register_condition(grs_cond_func_11139, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_ephi2, e_ephibb2};
+
+      ext_grs_act_register_condition(grs_cond_func_11142, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(bb0_134) = Block \ []*/
+      ext_grs_node_t *n_bb0_134 = ext_grs_act_add_related_node(pattern, "bb0_134", grs_op_Block, mode_ANY, 4, n_bb0);
+      /* TODO typeof(x) = IR_node \ []*/
+      ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 12);
+      /* TODO typeof(jmp_135) = Jmp \ []*/
+      ext_grs_node_t *n_jmp_135 = ext_grs_act_add_related_node(pattern, "jmp_135", grs_op_Jmp, mode_ANY, 7, n_jmp);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge1_136 = ext_grs_act_add_edge(pattern, "_edge1_136", ext_grs_NO_EDGE_POS, n_bb0_134, n_x, 16);
+      ext_grs_edge_t *e__edge6_137 = ext_grs_act_add_related_edge(pattern, "_edge6_137", ext_grs_NO_EDGE_POS, n_bb0_134, n_jmp_135, 5, e__edge6);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+    { /* NAC 1  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(phi_138) = Phi \ []*/
+      ext_grs_node_t *n_phi_138 = ext_grs_act_add_related_node(pattern, "phi_138", grs_op_Phi, mode_ANY, 1, n_phi);
+      /* TODO typeof(x2_139) = IR_node \ []*/
+      ext_grs_node_t *n_x2_139 = ext_grs_act_add_related_node(pattern, "x2_139", grs_op_IR_node, mode_ANY, 3, n_x2);
+      /* TODO typeof(x) = IR_node \ []*/
+      ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 13);
+      /* TODO typeof(x1_140) = IR_node \ []*/
+      ext_grs_node_t *n_x1_140 = ext_grs_act_add_related_node(pattern, "x1_140", grs_op_IR_node, mode_ANY, 9, n_x1);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge1_141 = ext_grs_act_add_edge(pattern, "_edge1_141", ext_grs_NO_EDGE_POS, n_x2_139, n_phi_138, 17);
+      ext_grs_edge_t *e__edge0_142 = ext_grs_act_add_edge(pattern, "_edge0_142", ext_grs_NO_EDGE_POS, n_x1_140, n_phi_138, 18);
+      ext_grs_edge_t *e__edge2_143 = ext_grs_act_add_edge(pattern, "_edge2_143", ext_grs_NO_EDGE_POS, n_x, n_phi_138, 19);
+
+      /* The conditions of the pattern */
+    } /* NAC 1  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* mux_a */
+
+
+/* functions for evaluation of conditions of action sse2_pmaxsw */
+
+/* functions for building the pattern of action sse2_pmaxsw */
+static _inline ext_grs_action_t *grs_action_sse2_pmaxsw_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "sse2_pmaxsw");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(y) = IR_node \ []*/
+    ext_grs_node_t *n_y = ext_grs_act_add_node(pattern, "y", grs_op_IR_node, mode_ANY, 0);
+    /* TODO typeof(cmp) = Cmp \ []*/
+    ext_grs_node_t *n_cmp = ext_grs_act_add_node(pattern, "cmp", grs_op_Cmp, mode_ANY, 1);
+    /* TODO typeof(mux) = Mux \ []*/
+    ext_grs_node_t *n_mux = ext_grs_act_add_node(pattern, "mux", grs_op_Mux, mode_ANY, 2);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 3);
+    /* TODO typeof(pb) = Proj \ []*/
+    ext_grs_node_t *n_pb = ext_grs_act_add_node(pattern, "pb", grs_op_Proj, mode_ANY, 4);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_y, n_cmp, 0);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_cmp, n_pb, 1);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_y, n_mux, 2);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_mux, 3);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_x, n_cmp, 4);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_pb, n_mux, 5);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* sse2_pmaxsw */
+
+
+/* functions for evaluation of conditions of action sync_load_a */
+static int grs_cond_func_10670(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+static int grs_cond_func_10673(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+static int grs_cond_func_10676(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == "M";
+}
+static int grs_cond_func_10679(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+static int grs_cond_func_10682(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+
+/* functions for building the pattern of action sync_load_a */
+static _inline ext_grs_action_t *grs_action_sync_load_a_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "sync_load_a");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(mm) = Mode \ []*/
+    ext_grs_node_t *n_mm = ext_grs_act_add_node(pattern, "mm", grs_op_Mode, mode_ANY, 0);
+    /* TODO typeof(ld_2) = Load \ []*/
+    ext_grs_node_t *n_ld_2 = ext_grs_act_add_node(pattern, "ld_2", grs_op_Load, mode_ANY, 1);
+    /* TODO typeof(ld_1) = Load \ []*/
+    ext_grs_node_t *n_ld_1 = ext_grs_act_add_node(pattern, "ld_1", grs_op_Load, mode_ANY, 2);
+/* mode edge: edge $edge4*/
+    /* TODO typeof(p_2) = Proj \ []*/
+    ext_grs_node_t *n_p_2 = ext_grs_act_add_node(pattern, "p_2", grs_op_Proj, mode_ANY, 3);
+    /* TODO typeof(x) = IR_node \ [node type SyncArity2, node type Sync]*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 4);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 5);
+/* mode edge: edge $edge3*/
+    /* TODO typeof(p_1) = Proj \ []*/
+    ext_grs_node_t *n_p_1 = ext_grs_act_add_node(pattern, "p_1", grs_op_Proj, mode_ANY, 6);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_mm, n_p_1, 0);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_ld_1, n_p_1, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_ld_1, 2);
+    ext_grs_edge_t *e_el1 = ext_grs_act_add_edge(pattern, "el1", ext_grs_NO_EDGE_POS, n_p_1, n_ld_2, 3);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_bb, n_p_2, 4);
+    ext_grs_edge_t *e_dfld2 = ext_grs_act_add_edge(pattern, "dfld2", ext_grs_NO_EDGE_POS, n_ld_2, n_p_2, 5);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_mm, n_p_2, 6);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_p_1};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10670, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_p_2};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10673, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_mm};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10676, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_ld_1};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10679, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_ld_2};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10682, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+    { /* NAC 0  */
+      ext_grs_graph_t *pattern = ext_grs_act_impose_negative(act);
+
+      /* The nodes of the pattern */
+      /* TODO typeof(l2) = Load \ []*/
+      ext_grs_node_t *n_l2 = ext_grs_act_add_node(pattern, "l2", grs_op_Load, mode_ANY, 7);
+      /* TODO typeof(x_144) = IR_node \ [node type SyncArity2, node type Sync]*/
+      ext_grs_node_t *n_x_144 = ext_grs_act_add_related_node(pattern, "x_144", grs_op_IR_node, mode_ANY, 4, n_x);
+
+      /* The edges of the pattern */
+      ext_grs_edge_t *e__edge0_145 = ext_grs_act_add_edge(pattern, "_edge0_145", ext_grs_NO_EDGE_POS, n_l2, n_x_144, 7);
+
+      /* The conditions of the pattern */
+    } /* NAC 0  */
+
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* sync_load_a */
+
+
+/* functions for evaluation of conditions of action sync_load_a_fake */
+
+/* functions for building the pattern of action sync_load_a_fake */
+static _inline ext_grs_action_t *grs_action_sync_load_a_fake_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "sync_load_a_fake");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(ld_2) = Load \ []*/
+    ext_grs_node_t *n_ld_2 = ext_grs_act_add_node(pattern, "ld_2", grs_op_Load, mode_ANY, 0);
+    /* TODO typeof(ld_1) = Load \ []*/
+    ext_grs_node_t *n_ld_1 = ext_grs_act_add_node(pattern, "ld_1", grs_op_Load, mode_ANY, 1);
+    /* TODO typeof(p_2) = Proj \ []*/
+    ext_grs_node_t *n_p_2 = ext_grs_act_add_node(pattern, "p_2", grs_op_Proj, mode_ANY, 2);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 3);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 4);
+    /* TODO typeof(p_1) = Proj \ []*/
+    ext_grs_node_t *n_p_1 = ext_grs_act_add_node(pattern, "p_1", grs_op_Proj, mode_ANY, 5);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_ld_2, n_p_2, 0);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_ld_1, n_p_1, 1);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_ld_1, 2);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_p_1, n_ld_2, 3);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_bb, n_p_2, 4);
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* sync_load_a_fake */
+
+
+/* functions for evaluation of conditions of action sync_load_b */
+static int grs_cond_func_10862(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+static int grs_cond_func_10865(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == 0;
+}
+static int grs_cond_func_10868(ir_node **node_map, const ir_edge_t **edge_map) {
+  return  0 /* TODO attr access */ == "M";
+}
+
+/* functions for building the pattern of action sync_load_b */
+static _inline ext_grs_action_t *grs_action_sync_load_b_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "sync_load_b");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(mm) = Mode \ []*/
+    ext_grs_node_t *n_mm = ext_grs_act_add_node(pattern, "mm", grs_op_Mode, mode_ANY, 0);
+    /* TODO typeof(ld_1) = Load \ []*/
+    ext_grs_node_t *n_ld_1 = ext_grs_act_add_node(pattern, "ld_1", grs_op_Load, mode_ANY, 1);
+    /* TODO typeof(x) = IR_node \ []*/
+    ext_grs_node_t *n_x = ext_grs_act_add_node(pattern, "x", grs_op_IR_node, mode_ANY, 2);
+/* mode edge: edge $edge5*/
+    /* TODO typeof(sync) = Sync \ []*/
+    ext_grs_node_t *n_sync = ext_grs_act_add_node(pattern, "sync", grs_op_Sync, mode_ANY, 3);
+    /* TODO typeof(bb) = Block \ []*/
+    ext_grs_node_t *n_bb = ext_grs_act_add_node(pattern, "bb", grs_op_Block, mode_ANY, 4);
+/* mode edge: edge $edge4*/
+    /* TODO typeof(p) = Proj \ []*/
+    ext_grs_node_t *n_p = ext_grs_act_add_node(pattern, "p", grs_op_Proj, mode_ANY, 5);
+    /* TODO typeof(ld) = Load \ []*/
+    ext_grs_node_t *n_ld = ext_grs_act_add_node(pattern, "ld", grs_op_Load, mode_ANY, 6);
+/* mode edge: edge $edge3*/
+    /* TODO typeof(p_1) = Proj \ []*/
+    ext_grs_node_t *n_p_1 = ext_grs_act_add_node(pattern, "p_1", grs_op_Proj, mode_ANY, 7);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e__edge3 = ext_grs_act_add_edge(pattern, "_edge3", ext_grs_NO_EDGE_POS, n_mm, n_p_1, 0);
+    ext_grs_edge_t *e__edge5 = ext_grs_act_add_edge(pattern, "_edge5", ext_grs_NO_EDGE_POS, n_mm, n_sync, 1);
+    ext_grs_edge_t *e_bb1 = ext_grs_act_add_edge(pattern, "bb1", ext_grs_NO_EDGE_POS, n_bb, n_p, 2);
+    ext_grs_edge_t *e__edge1 = ext_grs_act_add_edge(pattern, "_edge1", ext_grs_NO_EDGE_POS, n_ld_1, n_p_1, 3);
+    ext_grs_edge_t *e__edge0 = ext_grs_act_add_edge(pattern, "_edge0", ext_grs_NO_EDGE_POS, n_x, n_ld_1, 4);
+    ext_grs_edge_t *e_dfp = ext_grs_act_add_edge(pattern, "dfp", ext_grs_NO_EDGE_POS, n_ld, n_p, 5);
+    ext_grs_edge_t *e_el1 = ext_grs_act_add_edge(pattern, "el1", ext_grs_NO_EDGE_POS, n_sync, n_ld, 6);
+    ext_grs_edge_t *e__edge2 = ext_grs_act_add_edge(pattern, "_edge2", ext_grs_NO_EDGE_POS, n_p_1, n_sync, 7);
+    ext_grs_edge_t *e__edge4 = ext_grs_act_add_edge(pattern, "_edge4", ext_grs_NO_EDGE_POS, n_mm, n_p, 8);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_p_1};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10862, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_p};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10865, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_mm};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_10868, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* sync_load_b */
+
+
+/* functions for evaluation of conditions of action sync_set_arity2 */
+
+/* functions for building the pattern of action sync_set_arity2 */
+static _inline ext_grs_action_t *grs_action_sync_set_arity2_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_test, "sync_set_arity2");
+  int check;
+  { /* L */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    /* TODO typeof(s) = SyncArity2 \ []*/
+    ext_grs_node_t *n_s = ext_grs_act_add_node(pattern, "s", grs_op_SyncArity2, mode_ANY, 0);
+
+    /* The edges of the pattern */
+
+    /* The conditions of the pattern */
+    /* The negative parts of the pattern */
+  } /* L */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* sync_set_arity2 */
+
+
+/* global variables containing the actions */
+ext_grs_action_t *ext_grs_action_FirmAct_KillAllButEnd;
+ext_grs_action_t *ext_grs_action_FirmAct_KillBlock;
+ext_grs_action_t *ext_grs_action_FirmAct_KillCall;
+ext_grs_action_t *ext_grs_action_FirmAct_KillConst;
+ext_grs_action_t *ext_grs_action_FirmAct_KillEntity;
+ext_grs_action_t *ext_grs_action_FirmAct_KillMemoryEdges;
+ext_grs_action_t *ext_grs_action_FirmAct_KillMethod_IRG;
+ext_grs_action_t *ext_grs_action_FirmAct_KillMode;
+ext_grs_action_t *ext_grs_action_FirmAct_KillType;
+ext_grs_action_t *ext_grs_action_FirmAct_KillUselessConv;
+ext_grs_action_t *ext_grs_action_FirmAct_MAX;
+ext_grs_action_t *ext_grs_action_FirmAct_MAX2;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_0a;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_1a;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_1b;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_1c;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_1d;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_2a;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_2b;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_2c;
+ext_grs_action_t *ext_grs_action_FirmAct_PBQP_2d;
+ext_grs_action_t *ext_grs_action_FirmAct_V2LD_a;
+ext_grs_action_t *ext_grs_action_FirmAct_V2LD_b;
+ext_grs_action_t *ext_grs_action_FirmAct_V2LD_c;
+ext_grs_action_t *ext_grs_action_FirmAct_V2LD_d;
+ext_grs_action_t *ext_grs_action_FirmAct_V2ST_a;
+ext_grs_action_t *ext_grs_action_FirmAct_V2SUB_a;
+ext_grs_action_t *ext_grs_action_FirmAct_dead_Block;
+ext_grs_action_t *ext_grs_action_FirmAct_dead_Block_unify;
+ext_grs_action_t *ext_grs_action_FirmAct_dead_Block_unify2;
+ext_grs_action_t *ext_grs_action_FirmAct_dead_Load;
+ext_grs_action_t *ext_grs_action_FirmAct_dead_Ordinary;
+ext_grs_action_t *ext_grs_action_FirmAct_dead_Proj_Load_Proj;
+ext_grs_action_t *ext_grs_action_FirmAct_dead_double_mem;
+ext_grs_action_t *ext_grs_action_FirmAct_elim_AddSub;
+ext_grs_action_t *ext_grs_action_FirmAct_elim_SubAdd;
+ext_grs_action_t *ext_grs_action_FirmAct_ids_copy_cf;
+ext_grs_action_t *ext_grs_action_FirmAct_ids_copy_df;
+ext_grs_action_t *ext_grs_action_FirmAct_ids_copy_mem;
+ext_grs_action_t *ext_grs_action_FirmAct_ids_remove;
+ext_grs_action_t *ext_grs_action_FirmAct_mux_a;
+ext_grs_action_t *ext_grs_action_FirmAct_sse2_pmaxsw;
+ext_grs_action_t *ext_grs_action_FirmAct_sync_load_a;
+ext_grs_action_t *ext_grs_action_FirmAct_sync_load_a_fake;
+ext_grs_action_t *ext_grs_action_FirmAct_sync_load_b;
+ext_grs_action_t *ext_grs_action_FirmAct_sync_set_arity2;
+
+/* function for initializing the actions */
+ext_grs_action_init_FirmAct() {
+  init();
+  ext_grs_action_FirmAct_KillAllButEnd = grs_action_KillAllButEnd_init();
+  ext_grs_action_FirmAct_KillBlock = grs_action_KillBlock_init();
+  ext_grs_action_FirmAct_KillCall = grs_action_KillCall_init();
+  ext_grs_action_FirmAct_KillConst = grs_action_KillConst_init();
+  ext_grs_action_FirmAct_KillEntity = grs_action_KillEntity_init();
+  ext_grs_action_FirmAct_KillMemoryEdges = grs_action_KillMemoryEdges_init();
+  ext_grs_action_FirmAct_KillMethod_IRG = grs_action_KillMethod_IRG_init();
+  ext_grs_action_FirmAct_KillMode = grs_action_KillMode_init();
+  ext_grs_action_FirmAct_KillType = grs_action_KillType_init();
+  ext_grs_action_FirmAct_KillUselessConv = grs_action_KillUselessConv_init();
+  ext_grs_action_FirmAct_MAX = grs_action_MAX_init();
+  ext_grs_action_FirmAct_MAX2 = grs_action_MAX2_init();
+  ext_grs_action_FirmAct_PBQP_0a = grs_action_PBQP_0a_init();
+  ext_grs_action_FirmAct_PBQP_1a = grs_action_PBQP_1a_init();
+  ext_grs_action_FirmAct_PBQP_1b = grs_action_PBQP_1b_init();
+  ext_grs_action_FirmAct_PBQP_1c = grs_action_PBQP_1c_init();
+  ext_grs_action_FirmAct_PBQP_1d = grs_action_PBQP_1d_init();
+  ext_grs_action_FirmAct_PBQP_2a = grs_action_PBQP_2a_init();
+  ext_grs_action_FirmAct_PBQP_2b = grs_action_PBQP_2b_init();
+  ext_grs_action_FirmAct_PBQP_2c = grs_action_PBQP_2c_init();
+  ext_grs_action_FirmAct_PBQP_2d = grs_action_PBQP_2d_init();
+  ext_grs_action_FirmAct_V2LD_a = grs_action_V2LD_a_init();
+  ext_grs_action_FirmAct_V2LD_b = grs_action_V2LD_b_init();
+  ext_grs_action_FirmAct_V2LD_c = grs_action_V2LD_c_init();
+  ext_grs_action_FirmAct_V2LD_d = grs_action_V2LD_d_init();
+  ext_grs_action_FirmAct_V2ST_a = grs_action_V2ST_a_init();
+  ext_grs_action_FirmAct_V2SUB_a = grs_action_V2SUB_a_init();
+  ext_grs_action_FirmAct_dead_Block = grs_action_dead_Block_init();
+  ext_grs_action_FirmAct_dead_Block_unify = grs_action_dead_Block_unify_init();
+  ext_grs_action_FirmAct_dead_Block_unify2 = grs_action_dead_Block_unify2_init();
+  ext_grs_action_FirmAct_dead_Load = grs_action_dead_Load_init();
+  ext_grs_action_FirmAct_dead_Ordinary = grs_action_dead_Ordinary_init();
+  ext_grs_action_FirmAct_dead_Proj_Load_Proj = grs_action_dead_Proj_Load_Proj_init();
+  ext_grs_action_FirmAct_dead_double_mem = grs_action_dead_double_mem_init();
+  ext_grs_action_FirmAct_elim_AddSub = grs_action_elim_AddSub_init();
+  ext_grs_action_FirmAct_elim_SubAdd = grs_action_elim_SubAdd_init();
+  ext_grs_action_FirmAct_ids_copy_cf = grs_action_ids_copy_cf_init();
+  ext_grs_action_FirmAct_ids_copy_df = grs_action_ids_copy_df_init();
+  ext_grs_action_FirmAct_ids_copy_mem = grs_action_ids_copy_mem_init();
+  ext_grs_action_FirmAct_ids_remove = grs_action_ids_remove_init();
+  ext_grs_action_FirmAct_mux_a = grs_action_mux_a_init();
+  ext_grs_action_FirmAct_sse2_pmaxsw = grs_action_sse2_pmaxsw_init();
+  ext_grs_action_FirmAct_sync_load_a = grs_action_sync_load_a_init();
+  ext_grs_action_FirmAct_sync_load_a_fake = grs_action_sync_load_a_fake_init();
+  ext_grs_action_FirmAct_sync_load_b = grs_action_sync_load_b_init();
+  ext_grs_action_FirmAct_sync_set_arity2 = grs_action_sync_set_arity2_init();
+
+  /* establish inherritance */
+  ext_grs_appoint_heir(grs_op_ASM_CAST, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_VProj, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_VProj, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_Unary);
+
+  ext_grs_appoint_heir(grs_op_Nary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Entity, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_sse, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Ordinary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_First_right_load, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_Const, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Const, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Tarval, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_Primitive, grs_op_Type);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicFP, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_InstOf, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicMMX, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Left_blocked, grs_op_Blocked);
+  ext_grs_appoint_heir(grs_op_Left_blocked, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_Compound, grs_op_Type);
+
+  ext_grs_appoint_heir(grs_op_IR_node, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_Non_pattern_block, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicGP, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Trinary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Non_output_add, grs_op_Non_output);
+  ext_grs_appoint_heir(grs_op_Non_output_add, grs_op_Add);
+
+  ext_grs_appoint_heir(grs_op_SyncArity2, grs_op_Sync);
+
+  ext_grs_appoint_heir(grs_op_min, grs_op_IntrinsicGP);
+
+  ext_grs_appoint_heir(grs_op_End, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_End, grs_op_Special);
+
+  ext_grs_appoint_heir(grs_op_Binary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_CCopy, grs_op_IntrinsicGP);
+
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Commutative);
+
+  ext_grs_appoint_heir(grs_op_ASM_node, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Free, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Free, grs_op_Memory);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse_sse, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Break, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Break, grs_op_Controlflow);
+
+  ext_grs_appoint_heir(grs_op_G2s_complex, grs_op_G2s);
+
+  ext_grs_appoint_heir(grs_op_Union, grs_op_Compound);
+
+  ext_grs_appoint_heir(grs_op_Start_non_pattern, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_Unary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Commutative);
+
+  ext_grs_appoint_heir(grs_op_IntConst, grs_op_Const);
+
+  ext_grs_appoint_heir(grs_op_Non_output, grs_op_Non_pattern);
+  ext_grs_appoint_heir(grs_op_Non_output, grs_op_Non_replace);
+
+  ext_grs_appoint_heir(grs_op_Start, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Start, grs_op_Special);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicSSE, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Create_helper, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_MemNode, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_MemNode, grs_op_Memory);
+
+  ext_grs_appoint_heir(grs_op_Right_loads, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_Left_load_helper, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_Match, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_EndReg, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Tuple, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_New_vop, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_Controlflow, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Pointer, grs_op_Type);
+
+  ext_grs_appoint_heir(grs_op_FIRM_node, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Marker, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_Non_output_Block, grs_op_Block);
+  ext_grs_appoint_heir(grs_op_Non_output_Block, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_V2);
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_pi);
+
+  ext_grs_appoint_heir(grs_op_V2, grs_op_Vector);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicGP3, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Commutative);
+
+  ext_grs_appoint_heir(grs_op_V2Load, grs_op_V2);
+
+  ext_grs_appoint_heir(grs_op_Special, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicMatch, grs_op_Match);
+
+  ext_grs_appoint_heir(grs_op_Method, grs_op_Type);
+
+  ext_grs_appoint_heir(grs_op_Block, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Block, grs_op_Special);
+
+  ext_grs_appoint_heir(grs_op_G2s_marker, grs_op_G2s);
+
+  ext_grs_appoint_heir(grs_op_IgnoreCF, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Id, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_V2Sub, grs_op_V2);
+
+  ext_grs_appoint_heir(grs_op_Bad, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Call, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_AnyProj, grs_op_Proj);
+  ext_grs_appoint_heir(grs_op_AnyProj, grs_op_IgnoreAttrs);
+
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_pi);
+
+  ext_grs_appoint_heir(grs_op_Conv, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Conv, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Sync, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Sync, grs_op_Memory);
+
+  ext_grs_appoint_heir(grs_op_Phi, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Phi, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Vector, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_IgnoreAttrs, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_pi);
+
+  ext_grs_appoint_heir(grs_op_Confirm, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_Array, grs_op_Type);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_store, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Proj, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Proj, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_sse, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Return_non_pattern, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_Commutative, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IgnoreCF_Vop, grs_op_IgnoreCF);
+  ext_grs_appoint_heir(grs_op_IgnoreCF_Vop, grs_op_Vop);
+
+  ext_grs_appoint_heir(grs_op_And, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Commutative);
+
+  ext_grs_appoint_heir(grs_op_Left_loads, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_Or, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Commutative);
+
+  ext_grs_appoint_heir(grs_op_Type, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_Alloc, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Alloc, grs_op_Memory);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_pi, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Filter, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Cmp, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Cmp, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Memory, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_Unary);
+
+  ext_grs_appoint_heir(grs_op_G2s, grs_op_Node);
+
+
+  ext_grs_appoint_heir(grs_op_Not, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Not, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Not, grs_op_Unary);
+
+  ext_grs_appoint_heir(grs_op_Add, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Commutative);
+
+  ext_grs_appoint_heir(grs_op_Enum, grs_op_Type);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_CallBegin, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Right_load_helper, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_G2s_allowed, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_IgnoreCF_IR_node, grs_op_IgnoreCF);
+  ext_grs_appoint_heir(grs_op_IgnoreCF_IR_node, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Vop, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_V4, grs_op_Vector);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_reg_sse, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Raise, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Raise, grs_op_Controlflow);
+
+  ext_grs_appoint_heir(grs_op_Blocked, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_Jmp, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Jmp, grs_op_Controlflow);
+
+  ext_grs_appoint_heir(grs_op_Arithmetic, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Mux, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mux, grs_op_Trinary);
+
+  ext_grs_appoint_heir(grs_op_max, grs_op_IntrinsicGP);
+
+  ext_grs_appoint_heir(grs_op_G2s_param, grs_op_G2s);
+
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_LoadStore, grs_op_Load);
+  ext_grs_appoint_heir(grs_op_LoadStore, grs_op_Store);
+
+  ext_grs_appoint_heir(grs_op_Non_replace, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Non_output_Ir_node, grs_op_Non_output);
+  ext_grs_appoint_heir(grs_op_Non_output_Ir_node, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Meth_entity, grs_op_Entity);
+
+  ext_grs_appoint_heir(grs_op_Non_pattern, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Sel, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Mode_marker, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_VMode, grs_op_Mode);
+  ext_grs_appoint_heir(grs_op_VMode, grs_op_Non_pattern);
+
+  ext_grs_appoint_heir(grs_op_Last_left_load, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_Struct, grs_op_Compound);
+
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_pi);
+
+  ext_grs_appoint_heir(grs_op_EndExcept, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_EndExcept, grs_op_Controlflow);
+
+  ext_grs_appoint_heir(grs_op_Store, grs_op_MemNode);
+
+  ext_grs_appoint_heir(grs_op_IgnoreCF_Conv, grs_op_IgnoreCF);
+  ext_grs_appoint_heir(grs_op_IgnoreCF_Conv, grs_op_Conv);
+
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_pi);
+
+  ext_grs_appoint_heir(grs_op_Load, grs_op_MemNode);
+
+  ext_grs_appoint_heir(grs_op_Right_blocked, grs_op_Blocked);
+  ext_grs_appoint_heir(grs_op_Right_blocked, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_G2s_r128_int_4, grs_op_G2s);
+
+  ext_grs_appoint_heir(grs_op_CMOV, grs_op_IntrinsicGP);
+
+  ext_grs_appoint_heir(grs_op_Negative, grs_op_Non_output);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse_store, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_SymConst, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_SymConst, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Associative, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V2Store, grs_op_V2);
+
+  ext_grs_appoint_heir(grs_op_Cast, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_Unknown, grs_op_IR_node);
+
+  ext_grs_appoint_heir(grs_op_Visual_helper, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_Div, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Div, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Div, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_ASM_Block, grs_op_ASM_node);
+
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_Controlflow);
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_Ordinary);
+
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_V2);
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_pi);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_reg_sse_sse, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_Method_IRG, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_Class, grs_op_Compound);
+
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_Binary);
+
+  ext_grs_appoint_heir(grs_op_Mode, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_StartBlock, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Return, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Return, grs_op_Controlflow);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_store, grs_op_Intrinsic);
+
+  ext_grs_appoint_heir(grs_op_NoMem, grs_op_IR_node);
+
+  ext_grs_inheritance_mature();
+}

diff --git a/ir/be/grgen/simd/generated/existing_rules.c b/ir/be/grgen/simd/generated/existing_rules.c
new file mode 100644 (file)
index 0000000..ff1193d
--- /dev/null
+++ b/ir/be/grgen/simd/generated/existing_rules.c
@@ -0,0 +1,2 @@
+/* Dump all the function pointers to the rules to be called here in an array
+   so that the rules can be called in a row */

diff --git a/ir/be/grgen/simd/generated/gen_patterns.c b/ir/be/grgen/simd/generated/gen_patterns.c
new file mode 100644 (file)
index 0000000..c6910dd
--- /dev/null
+++ b/ir/be/grgen/simd/generated/gen_patterns.c
@@ -0,0 +1,11324 @@
+/* generated by grgen, don't edit */
+
+#include <assert.h>
+#include "libfirm/firm.h"
+#include "grs/grs.h"
+#include "grs/simd/firm_node_ext.h"
+
+/* nodeTypeMap */
+ir_op* grs_op_Intrinsic_addr_addr_store;
+ir_op* grs_op_Entity;
+ir_op* grs_op_End;
+ir_op* grs_op_Intrinsic_addr_sse;
+ir_op* grs_op_Union;
+ir_op* grs_op_Intrinsic_addr_addr_sse;
+ir_op* grs_op_Special;
+ir_op* grs_op_Struct;
+ir_op* grs_op_Memory;
+ir_op* grs_op_Complex;
+ir_op* grs_op_Intrinsic_sse_addr_sse;
+ir_op* grs_op_Intrinsic_sse_sse;
+ir_op* grs_op_Tarval;
+ir_op* grs_op_Node;
+ir_op* grs_op_V2Load;
+ir_op* grs_op_V2Sub;
+ir_op* grs_op_IR_node;
+ir_op* grs_op_CMOV;
+ir_op* grs_op_Match;
+ir_op* grs_op_SymConst;
+ir_op* grs_op_Store;
+ir_op* grs_op_Break;
+ir_op* grs_op_V4pi_2;
+ir_op* grs_op_V4pi_1;
+ir_op* grs_op_V4pi_4;
+ir_op* grs_op_V4pi_3;
+ir_op* grs_op_Unary;
+ir_op* grs_op_Div;
+ir_op* grs_op_Free;
+ir_op* grs_op_Trinary;
+ir_op* grs_op_IntrinsicMatch;
+ir_op* grs_op_Bad;
+ir_op* grs_op_Confirm;
+ir_op* grs_op_IntConst;
+ir_op* grs_op_Nary;
+ir_op* grs_op_Raise;
+ir_op* grs_op_Id;
+ir_op* grs_op_Or;
+ir_op* grs_op_Eor;
+ir_op* grs_op_Vector;
+ir_op* grs_op_Intrinsic_sse_reg_sse;
+ir_op* grs_op_Add;
+ir_op* grs_op_VProj;
+ir_op* grs_op_IntrinsicMMX;
+ir_op* grs_op_Const;
+ir_op* grs_op_Sel;
+ir_op* grs_op_Sub;
+ir_op* grs_op_Ordinary;
+ir_op* grs_op_Tuple;
+ir_op* grs_op_MultipleAdd;
+ir_op* grs_op_IntrinsicFP;
+ir_op* grs_op_Cmp;
+ir_op* grs_op_Mulh;
+ir_op* grs_op_And;
+ir_op* grs_op_Method_IRG;
+ir_op* grs_op_CCopy;
+ir_op* grs_op_EndReg;
+ir_op* grs_op_Call;
+ir_op* grs_op_Cast;
+ir_op* grs_op_EndExcept;
+ir_op* grs_op_Sync;
+ir_op* grs_op_Rot;
+ir_op* grs_op_NoMem;
+ir_op* grs_op_Unknown;
+ir_op* grs_op_Primitive;
+ir_op* grs_op_IntrinsicGP;
+ir_op* grs_op_Mux;
+ir_op* grs_op_pi;
+ir_op* grs_op_Quot;
+ir_op* grs_op_Method;
+ir_op* grs_op_Jmp;
+ir_op* grs_op_Mul;
+ir_op* grs_op_Associative;
+ir_op* grs_op_Start;
+ir_op* grs_op_SyncArity2;
+ir_op* grs_op_Arithmetic;
+ir_op* grs_op_Intrinsic_sse_addr_store;
+ir_op* grs_op_Conv;
+ir_op* grs_op_Intrinsic;
+ir_op* grs_op_VectorBase;
+ir_op* grs_op_V2Store;
+ir_op* grs_op_Cond;
+ir_op* grs_op_Class;
+ir_op* grs_op_Abs;
+ir_op* grs_op_V2pi_1;
+ir_op* grs_op_Commutative;
+ir_op* grs_op_V2pi_2;
+ir_op* grs_op_StartBlock;
+ir_op* grs_op_Phi;
+ir_op* grs_op_Block;
+ir_op* grs_op_MemNode;
+ir_op* grs_op_Enum;
+ir_op* grs_op_Shrs;
+ir_op* grs_op_Array;
+ir_op* grs_op_max;
+ir_op* grs_op_Proj;
+ir_op* grs_op_Mod;
+ir_op* grs_op_Binary;
+ir_op* grs_op_V2;
+ir_op* grs_op_Not;
+ir_op* grs_op_V4;
+ir_op* grs_op_Intrinsic_sse_sse_sse;
+ir_op* grs_op_Intrinsic_reg_sse_sse;
+ir_op* grs_op_DivMod;
+ir_op* grs_op_FIRM_node;
+ir_op* grs_op_Alloc;
+ir_op* grs_op_Pointer;
+ir_op* grs_op_Minus;
+ir_op* grs_op_Type;
+ir_op* grs_op_Return;
+ir_op* grs_op_IntrinsicSSE;
+ir_op* grs_op_Filter;
+ir_op* grs_op_Controlflow;
+ir_op* grs_op_min;
+ir_op* grs_op_Intrinsic_addr_sse_store;
+ir_op* grs_op_Compound;
+ir_op* grs_op_Load;
+ir_op* grs_op_Shl;
+ir_op* grs_op_IgnoreCF;
+ir_op* grs_op_Shr;
+ir_op* grs_op_InstOf;
+ir_op* grs_op_IntrinsicGP3;
+ir_op* grs_op_IR_Keep;
+ir_op* grs_op_CallBegin;
+/* nodeTypeMap END */
+
+/* init node ops and modes */
+static void init() {
+  grs_op_Intrinsic_addr_addr_store = ext_grs_lookup_op("Intrinsic_addr_addr_store");
+  grs_op_Intrinsic_addr_addr_store = grs_op_Intrinsic_addr_addr_store ? grs_op_Intrinsic_addr_addr_store : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_addr_store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Entity = ext_grs_lookup_op("Entity");
+  grs_op_Entity = grs_op_Entity ? grs_op_Entity : new_ir_op(get_next_ir_opcode(), "Entity", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_End = ext_grs_lookup_op("End");
+  grs_op_End = grs_op_End ? grs_op_End : new_ir_op(get_next_ir_opcode(), "End", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_addr_sse = ext_grs_lookup_op("Intrinsic_addr_sse");
+  grs_op_Intrinsic_addr_sse = grs_op_Intrinsic_addr_sse ? grs_op_Intrinsic_addr_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Union = ext_grs_lookup_op("Union");
+  grs_op_Union = grs_op_Union ? grs_op_Union : new_ir_op(get_next_ir_opcode(), "Union", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_addr_addr_sse = ext_grs_lookup_op("Intrinsic_addr_addr_sse");
+  grs_op_Intrinsic_addr_addr_sse = grs_op_Intrinsic_addr_addr_sse ? grs_op_Intrinsic_addr_addr_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_addr_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Special = ext_grs_lookup_op("Special");
+  grs_op_Special = grs_op_Special ? grs_op_Special : new_ir_op(get_next_ir_opcode(), "Special", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Struct = ext_grs_lookup_op("Struct");
+  grs_op_Struct = grs_op_Struct ? grs_op_Struct : new_ir_op(get_next_ir_opcode(), "Struct", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Memory = ext_grs_lookup_op("Memory");
+  grs_op_Memory = grs_op_Memory ? grs_op_Memory : new_ir_op(get_next_ir_opcode(), "Memory", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Complex = ext_grs_lookup_op("Complex");
+  grs_op_Complex = grs_op_Complex ? grs_op_Complex : new_ir_op(get_next_ir_opcode(), "Complex", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_addr_sse = ext_grs_lookup_op("Intrinsic_sse_addr_sse");
+  grs_op_Intrinsic_sse_addr_sse = grs_op_Intrinsic_sse_addr_sse ? grs_op_Intrinsic_sse_addr_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_addr_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_sse = ext_grs_lookup_op("Intrinsic_sse_sse");
+  grs_op_Intrinsic_sse_sse = grs_op_Intrinsic_sse_sse ? grs_op_Intrinsic_sse_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Tarval = ext_grs_lookup_op("Tarval");
+  grs_op_Tarval = grs_op_Tarval ? grs_op_Tarval : new_ir_op(get_next_ir_opcode(), "Tarval", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Node = ext_grs_lookup_op("Node");
+  grs_op_Node = grs_op_Node ? grs_op_Node : new_ir_op(get_next_ir_opcode(), "Node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2Load = ext_grs_lookup_op("V2Load");
+  grs_op_V2Load = grs_op_V2Load ? grs_op_V2Load : new_ir_op(get_next_ir_opcode(), "V2Load", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2Sub = ext_grs_lookup_op("V2Sub");
+  grs_op_V2Sub = grs_op_V2Sub ? grs_op_V2Sub : new_ir_op(get_next_ir_opcode(), "V2Sub", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IR_node = ext_grs_lookup_op("IR_node");
+  grs_op_IR_node = grs_op_IR_node ? grs_op_IR_node : new_ir_op(get_next_ir_opcode(), "IR_node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_CMOV = ext_grs_lookup_op("CMOV");
+  grs_op_CMOV = grs_op_CMOV ? grs_op_CMOV : new_ir_op(get_next_ir_opcode(), "CMOV", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Match = ext_grs_lookup_op("Match");
+  grs_op_Match = grs_op_Match ? grs_op_Match : new_ir_op(get_next_ir_opcode(), "Match", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_SymConst = ext_grs_lookup_op("SymConst");
+  grs_op_SymConst = grs_op_SymConst ? grs_op_SymConst : new_ir_op(get_next_ir_opcode(), "SymConst", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Store = ext_grs_lookup_op("Store");
+  grs_op_Store = grs_op_Store ? grs_op_Store : new_ir_op(get_next_ir_opcode(), "Store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Break = ext_grs_lookup_op("Break");
+  grs_op_Break = grs_op_Break ? grs_op_Break : new_ir_op(get_next_ir_opcode(), "Break", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_2 = ext_grs_lookup_op("V4pi_2");
+  grs_op_V4pi_2 = grs_op_V4pi_2 ? grs_op_V4pi_2 : new_ir_op(get_next_ir_opcode(), "V4pi_2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_1 = ext_grs_lookup_op("V4pi_1");
+  grs_op_V4pi_1 = grs_op_V4pi_1 ? grs_op_V4pi_1 : new_ir_op(get_next_ir_opcode(), "V4pi_1", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_4 = ext_grs_lookup_op("V4pi_4");
+  grs_op_V4pi_4 = grs_op_V4pi_4 ? grs_op_V4pi_4 : new_ir_op(get_next_ir_opcode(), "V4pi_4", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4pi_3 = ext_grs_lookup_op("V4pi_3");
+  grs_op_V4pi_3 = grs_op_V4pi_3 ? grs_op_V4pi_3 : new_ir_op(get_next_ir_opcode(), "V4pi_3", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Unary = ext_grs_lookup_op("Unary");
+  grs_op_Unary = grs_op_Unary ? grs_op_Unary : new_ir_op(get_next_ir_opcode(), "Unary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Div = ext_grs_lookup_op("Div");
+  grs_op_Div = grs_op_Div ? grs_op_Div : new_ir_op(get_next_ir_opcode(), "Div", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Free = ext_grs_lookup_op("Free");
+  grs_op_Free = grs_op_Free ? grs_op_Free : new_ir_op(get_next_ir_opcode(), "Free", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Trinary = ext_grs_lookup_op("Trinary");
+  grs_op_Trinary = grs_op_Trinary ? grs_op_Trinary : new_ir_op(get_next_ir_opcode(), "Trinary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicMatch = ext_grs_lookup_op("IntrinsicMatch");
+  grs_op_IntrinsicMatch = grs_op_IntrinsicMatch ? grs_op_IntrinsicMatch : new_ir_op(get_next_ir_opcode(), "IntrinsicMatch", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Bad = ext_grs_lookup_op("Bad");
+  grs_op_Bad = grs_op_Bad ? grs_op_Bad : new_ir_op(get_next_ir_opcode(), "Bad", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Confirm = ext_grs_lookup_op("Confirm");
+  grs_op_Confirm = grs_op_Confirm ? grs_op_Confirm : new_ir_op(get_next_ir_opcode(), "Confirm", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntConst = ext_grs_lookup_op("IntConst");
+  grs_op_IntConst = grs_op_IntConst ? grs_op_IntConst : new_ir_op(get_next_ir_opcode(), "IntConst", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Nary = ext_grs_lookup_op("Nary");
+  grs_op_Nary = grs_op_Nary ? grs_op_Nary : new_ir_op(get_next_ir_opcode(), "Nary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Raise = ext_grs_lookup_op("Raise");
+  grs_op_Raise = grs_op_Raise ? grs_op_Raise : new_ir_op(get_next_ir_opcode(), "Raise", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Id = ext_grs_lookup_op("Id");
+  grs_op_Id = grs_op_Id ? grs_op_Id : new_ir_op(get_next_ir_opcode(), "Id", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Or = ext_grs_lookup_op("Or");
+  grs_op_Or = grs_op_Or ? grs_op_Or : new_ir_op(get_next_ir_opcode(), "Or", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Eor = ext_grs_lookup_op("Eor");
+  grs_op_Eor = grs_op_Eor ? grs_op_Eor : new_ir_op(get_next_ir_opcode(), "Eor", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Vector = ext_grs_lookup_op("Vector");
+  grs_op_Vector = grs_op_Vector ? grs_op_Vector : new_ir_op(get_next_ir_opcode(), "Vector", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_reg_sse = ext_grs_lookup_op("Intrinsic_sse_reg_sse");
+  grs_op_Intrinsic_sse_reg_sse = grs_op_Intrinsic_sse_reg_sse ? grs_op_Intrinsic_sse_reg_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_reg_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Add = ext_grs_lookup_op("Add");
+  grs_op_Add = grs_op_Add ? grs_op_Add : new_ir_op(get_next_ir_opcode(), "Add", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_VProj = ext_grs_lookup_op("VProj");
+  grs_op_VProj = grs_op_VProj ? grs_op_VProj : new_ir_op(get_next_ir_opcode(), "VProj", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicMMX = ext_grs_lookup_op("IntrinsicMMX");
+  grs_op_IntrinsicMMX = grs_op_IntrinsicMMX ? grs_op_IntrinsicMMX : new_ir_op(get_next_ir_opcode(), "IntrinsicMMX", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Const = ext_grs_lookup_op("Const");
+  grs_op_Const = grs_op_Const ? grs_op_Const : new_ir_op(get_next_ir_opcode(), "Const", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Sel = ext_grs_lookup_op("Sel");
+  grs_op_Sel = grs_op_Sel ? grs_op_Sel : new_ir_op(get_next_ir_opcode(), "Sel", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Sub = ext_grs_lookup_op("Sub");
+  grs_op_Sub = grs_op_Sub ? grs_op_Sub : new_ir_op(get_next_ir_opcode(), "Sub", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Ordinary = ext_grs_lookup_op("Ordinary");
+  grs_op_Ordinary = grs_op_Ordinary ? grs_op_Ordinary : new_ir_op(get_next_ir_opcode(), "Ordinary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Tuple = ext_grs_lookup_op("Tuple");
+  grs_op_Tuple = grs_op_Tuple ? grs_op_Tuple : new_ir_op(get_next_ir_opcode(), "Tuple", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_MultipleAdd = ext_grs_lookup_op("MultipleAdd");
+  grs_op_MultipleAdd = grs_op_MultipleAdd ? grs_op_MultipleAdd : new_ir_op(get_next_ir_opcode(), "MultipleAdd", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicFP = ext_grs_lookup_op("IntrinsicFP");
+  grs_op_IntrinsicFP = grs_op_IntrinsicFP ? grs_op_IntrinsicFP : new_ir_op(get_next_ir_opcode(), "IntrinsicFP", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Cmp = ext_grs_lookup_op("Cmp");
+  grs_op_Cmp = grs_op_Cmp ? grs_op_Cmp : new_ir_op(get_next_ir_opcode(), "Cmp", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mulh = ext_grs_lookup_op("Mulh");
+  grs_op_Mulh = grs_op_Mulh ? grs_op_Mulh : new_ir_op(get_next_ir_opcode(), "Mulh", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_And = ext_grs_lookup_op("And");
+  grs_op_And = grs_op_And ? grs_op_And : new_ir_op(get_next_ir_opcode(), "And", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Method_IRG = ext_grs_lookup_op("Method_IRG");
+  grs_op_Method_IRG = grs_op_Method_IRG ? grs_op_Method_IRG : new_ir_op(get_next_ir_opcode(), "Method_IRG", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_CCopy = ext_grs_lookup_op("CCopy");
+  grs_op_CCopy = grs_op_CCopy ? grs_op_CCopy : new_ir_op(get_next_ir_opcode(), "CCopy", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_EndReg = ext_grs_lookup_op("EndReg");
+  grs_op_EndReg = grs_op_EndReg ? grs_op_EndReg : new_ir_op(get_next_ir_opcode(), "EndReg", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Call = ext_grs_lookup_op("Call");
+  grs_op_Call = grs_op_Call ? grs_op_Call : new_ir_op(get_next_ir_opcode(), "Call", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Cast = ext_grs_lookup_op("Cast");
+  grs_op_Cast = grs_op_Cast ? grs_op_Cast : new_ir_op(get_next_ir_opcode(), "Cast", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_EndExcept = ext_grs_lookup_op("EndExcept");
+  grs_op_EndExcept = grs_op_EndExcept ? grs_op_EndExcept : new_ir_op(get_next_ir_opcode(), "EndExcept", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Sync = ext_grs_lookup_op("Sync");
+  grs_op_Sync = grs_op_Sync ? grs_op_Sync : new_ir_op(get_next_ir_opcode(), "Sync", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Rot = ext_grs_lookup_op("Rot");
+  grs_op_Rot = grs_op_Rot ? grs_op_Rot : new_ir_op(get_next_ir_opcode(), "Rot", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_NoMem = ext_grs_lookup_op("NoMem");
+  grs_op_NoMem = grs_op_NoMem ? grs_op_NoMem : new_ir_op(get_next_ir_opcode(), "NoMem", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Unknown = ext_grs_lookup_op("Unknown");
+  grs_op_Unknown = grs_op_Unknown ? grs_op_Unknown : new_ir_op(get_next_ir_opcode(), "Unknown", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Primitive = ext_grs_lookup_op("Primitive");
+  grs_op_Primitive = grs_op_Primitive ? grs_op_Primitive : new_ir_op(get_next_ir_opcode(), "Primitive", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicGP = ext_grs_lookup_op("IntrinsicGP");
+  grs_op_IntrinsicGP = grs_op_IntrinsicGP ? grs_op_IntrinsicGP : new_ir_op(get_next_ir_opcode(), "IntrinsicGP", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mux = ext_grs_lookup_op("Mux");
+  grs_op_Mux = grs_op_Mux ? grs_op_Mux : new_ir_op(get_next_ir_opcode(), "Mux", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_pi = ext_grs_lookup_op("pi");
+  grs_op_pi = grs_op_pi ? grs_op_pi : new_ir_op(get_next_ir_opcode(), "pi", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Quot = ext_grs_lookup_op("Quot");
+  grs_op_Quot = grs_op_Quot ? grs_op_Quot : new_ir_op(get_next_ir_opcode(), "Quot", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Method = ext_grs_lookup_op("Method");
+  grs_op_Method = grs_op_Method ? grs_op_Method : new_ir_op(get_next_ir_opcode(), "Method", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Jmp = ext_grs_lookup_op("Jmp");
+  grs_op_Jmp = grs_op_Jmp ? grs_op_Jmp : new_ir_op(get_next_ir_opcode(), "Jmp", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mul = ext_grs_lookup_op("Mul");
+  grs_op_Mul = grs_op_Mul ? grs_op_Mul : new_ir_op(get_next_ir_opcode(), "Mul", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Associative = ext_grs_lookup_op("Associative");
+  grs_op_Associative = grs_op_Associative ? grs_op_Associative : new_ir_op(get_next_ir_opcode(), "Associative", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Start = ext_grs_lookup_op("Start");
+  grs_op_Start = grs_op_Start ? grs_op_Start : new_ir_op(get_next_ir_opcode(), "Start", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_SyncArity2 = ext_grs_lookup_op("SyncArity2");
+  grs_op_SyncArity2 = grs_op_SyncArity2 ? grs_op_SyncArity2 : new_ir_op(get_next_ir_opcode(), "SyncArity2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Arithmetic = ext_grs_lookup_op("Arithmetic");
+  grs_op_Arithmetic = grs_op_Arithmetic ? grs_op_Arithmetic : new_ir_op(get_next_ir_opcode(), "Arithmetic", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_addr_store = ext_grs_lookup_op("Intrinsic_sse_addr_store");
+  grs_op_Intrinsic_sse_addr_store = grs_op_Intrinsic_sse_addr_store ? grs_op_Intrinsic_sse_addr_store : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_addr_store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Conv = ext_grs_lookup_op("Conv");
+  grs_op_Conv = grs_op_Conv ? grs_op_Conv : new_ir_op(get_next_ir_opcode(), "Conv", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic = ext_grs_lookup_op("Intrinsic");
+  grs_op_Intrinsic = grs_op_Intrinsic ? grs_op_Intrinsic : new_ir_op(get_next_ir_opcode(), "Intrinsic", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_VectorBase = ext_grs_lookup_op("VectorBase");
+  grs_op_VectorBase = grs_op_VectorBase ? grs_op_VectorBase : new_ir_op(get_next_ir_opcode(), "VectorBase", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2Store = ext_grs_lookup_op("V2Store");
+  grs_op_V2Store = grs_op_V2Store ? grs_op_V2Store : new_ir_op(get_next_ir_opcode(), "V2Store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Cond = ext_grs_lookup_op("Cond");
+  grs_op_Cond = grs_op_Cond ? grs_op_Cond : new_ir_op(get_next_ir_opcode(), "Cond", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Class = ext_grs_lookup_op("Class");
+  grs_op_Class = grs_op_Class ? grs_op_Class : new_ir_op(get_next_ir_opcode(), "Class", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Abs = ext_grs_lookup_op("Abs");
+  grs_op_Abs = grs_op_Abs ? grs_op_Abs : new_ir_op(get_next_ir_opcode(), "Abs", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2pi_1 = ext_grs_lookup_op("V2pi_1");
+  grs_op_V2pi_1 = grs_op_V2pi_1 ? grs_op_V2pi_1 : new_ir_op(get_next_ir_opcode(), "V2pi_1", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Commutative = ext_grs_lookup_op("Commutative");
+  grs_op_Commutative = grs_op_Commutative ? grs_op_Commutative : new_ir_op(get_next_ir_opcode(), "Commutative", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2pi_2 = ext_grs_lookup_op("V2pi_2");
+  grs_op_V2pi_2 = grs_op_V2pi_2 ? grs_op_V2pi_2 : new_ir_op(get_next_ir_opcode(), "V2pi_2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_StartBlock = ext_grs_lookup_op("StartBlock");
+  grs_op_StartBlock = grs_op_StartBlock ? grs_op_StartBlock : new_ir_op(get_next_ir_opcode(), "StartBlock", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Phi = ext_grs_lookup_op("Phi");
+  grs_op_Phi = grs_op_Phi ? grs_op_Phi : new_ir_op(get_next_ir_opcode(), "Phi", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Block = ext_grs_lookup_op("Block");
+  grs_op_Block = grs_op_Block ? grs_op_Block : new_ir_op(get_next_ir_opcode(), "Block", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_MemNode = ext_grs_lookup_op("MemNode");
+  grs_op_MemNode = grs_op_MemNode ? grs_op_MemNode : new_ir_op(get_next_ir_opcode(), "MemNode", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Enum = ext_grs_lookup_op("Enum");
+  grs_op_Enum = grs_op_Enum ? grs_op_Enum : new_ir_op(get_next_ir_opcode(), "Enum", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Shrs = ext_grs_lookup_op("Shrs");
+  grs_op_Shrs = grs_op_Shrs ? grs_op_Shrs : new_ir_op(get_next_ir_opcode(), "Shrs", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Array = ext_grs_lookup_op("Array");
+  grs_op_Array = grs_op_Array ? grs_op_Array : new_ir_op(get_next_ir_opcode(), "Array", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_max = ext_grs_lookup_op("max");
+  grs_op_max = grs_op_max ? grs_op_max : new_ir_op(get_next_ir_opcode(), "max", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Proj = ext_grs_lookup_op("Proj");
+  grs_op_Proj = grs_op_Proj ? grs_op_Proj : new_ir_op(get_next_ir_opcode(), "Proj", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Mod = ext_grs_lookup_op("Mod");
+  grs_op_Mod = grs_op_Mod ? grs_op_Mod : new_ir_op(get_next_ir_opcode(), "Mod", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Binary = ext_grs_lookup_op("Binary");
+  grs_op_Binary = grs_op_Binary ? grs_op_Binary : new_ir_op(get_next_ir_opcode(), "Binary", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V2 = ext_grs_lookup_op("V2");
+  grs_op_V2 = grs_op_V2 ? grs_op_V2 : new_ir_op(get_next_ir_opcode(), "V2", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Not = ext_grs_lookup_op("Not");
+  grs_op_Not = grs_op_Not ? grs_op_Not : new_ir_op(get_next_ir_opcode(), "Not", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_V4 = ext_grs_lookup_op("V4");
+  grs_op_V4 = grs_op_V4 ? grs_op_V4 : new_ir_op(get_next_ir_opcode(), "V4", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_sse_sse_sse = ext_grs_lookup_op("Intrinsic_sse_sse_sse");
+  grs_op_Intrinsic_sse_sse_sse = grs_op_Intrinsic_sse_sse_sse ? grs_op_Intrinsic_sse_sse_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_sse_sse_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_reg_sse_sse = ext_grs_lookup_op("Intrinsic_reg_sse_sse");
+  grs_op_Intrinsic_reg_sse_sse = grs_op_Intrinsic_reg_sse_sse ? grs_op_Intrinsic_reg_sse_sse : new_ir_op(get_next_ir_opcode(), "Intrinsic_reg_sse_sse", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_DivMod = ext_grs_lookup_op("DivMod");
+  grs_op_DivMod = grs_op_DivMod ? grs_op_DivMod : new_ir_op(get_next_ir_opcode(), "DivMod", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_FIRM_node = ext_grs_lookup_op("FIRM_node");
+  grs_op_FIRM_node = grs_op_FIRM_node ? grs_op_FIRM_node : new_ir_op(get_next_ir_opcode(), "FIRM_node", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Alloc = ext_grs_lookup_op("Alloc");
+  grs_op_Alloc = grs_op_Alloc ? grs_op_Alloc : new_ir_op(get_next_ir_opcode(), "Alloc", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Pointer = ext_grs_lookup_op("Pointer");
+  grs_op_Pointer = grs_op_Pointer ? grs_op_Pointer : new_ir_op(get_next_ir_opcode(), "Pointer", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Minus = ext_grs_lookup_op("Minus");
+  grs_op_Minus = grs_op_Minus ? grs_op_Minus : new_ir_op(get_next_ir_opcode(), "Minus", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Type = ext_grs_lookup_op("Type");
+  grs_op_Type = grs_op_Type ? grs_op_Type : new_ir_op(get_next_ir_opcode(), "Type", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Return = ext_grs_lookup_op("Return");
+  grs_op_Return = grs_op_Return ? grs_op_Return : new_ir_op(get_next_ir_opcode(), "Return", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicSSE = ext_grs_lookup_op("IntrinsicSSE");
+  grs_op_IntrinsicSSE = grs_op_IntrinsicSSE ? grs_op_IntrinsicSSE : new_ir_op(get_next_ir_opcode(), "IntrinsicSSE", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Filter = ext_grs_lookup_op("Filter");
+  grs_op_Filter = grs_op_Filter ? grs_op_Filter : new_ir_op(get_next_ir_opcode(), "Filter", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Controlflow = ext_grs_lookup_op("Controlflow");
+  grs_op_Controlflow = grs_op_Controlflow ? grs_op_Controlflow : new_ir_op(get_next_ir_opcode(), "Controlflow", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_min = ext_grs_lookup_op("min");
+  grs_op_min = grs_op_min ? grs_op_min : new_ir_op(get_next_ir_opcode(), "min", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Intrinsic_addr_sse_store = ext_grs_lookup_op("Intrinsic_addr_sse_store");
+  grs_op_Intrinsic_addr_sse_store = grs_op_Intrinsic_addr_sse_store ? grs_op_Intrinsic_addr_sse_store : new_ir_op(get_next_ir_opcode(), "Intrinsic_addr_sse_store", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Compound = ext_grs_lookup_op("Compound");
+  grs_op_Compound = grs_op_Compound ? grs_op_Compound : new_ir_op(get_next_ir_opcode(), "Compound", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Load = ext_grs_lookup_op("Load");
+  grs_op_Load = grs_op_Load ? grs_op_Load : new_ir_op(get_next_ir_opcode(), "Load", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Shl = ext_grs_lookup_op("Shl");
+  grs_op_Shl = grs_op_Shl ? grs_op_Shl : new_ir_op(get_next_ir_opcode(), "Shl", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IgnoreCF = ext_grs_lookup_op("IgnoreCF");
+  grs_op_IgnoreCF = grs_op_IgnoreCF ? grs_op_IgnoreCF : new_ir_op(get_next_ir_opcode(), "IgnoreCF", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_Shr = ext_grs_lookup_op("Shr");
+  grs_op_Shr = grs_op_Shr ? grs_op_Shr : new_ir_op(get_next_ir_opcode(), "Shr", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_InstOf = ext_grs_lookup_op("InstOf");
+  grs_op_InstOf = grs_op_InstOf ? grs_op_InstOf : new_ir_op(get_next_ir_opcode(), "InstOf", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IntrinsicGP3 = ext_grs_lookup_op("IntrinsicGP3");
+  grs_op_IntrinsicGP3 = grs_op_IntrinsicGP3 ? grs_op_IntrinsicGP3 : new_ir_op(get_next_ir_opcode(), "IntrinsicGP3", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_IR_Keep = ext_grs_lookup_op("IR_Keep");
+  grs_op_IR_Keep = grs_op_IR_Keep ? grs_op_IR_Keep : new_ir_op(get_next_ir_opcode(), "IR_Keep", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+  grs_op_CallBegin = ext_grs_lookup_op("CallBegin");
+  grs_op_CallBegin = grs_op_CallBegin ? grs_op_CallBegin : new_ir_op(get_next_ir_opcode(), "CallBegin", op_pin_state_pinned,  irop_flag_none, oparity_dynamic,  0, 0, NULL);
+} /* init node ops and modes */
+
+/* functions for evaluation of conditions of action add_horz_4_32_variant0 */
+static int grs_cond_func_38675(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[6/* VProj1624 */]) == 1;
+}
+static int grs_cond_func_38678(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[3/* VProj1616 */]) == 0;
+}
+static int grs_cond_func_38681(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[5/* VProj1633 */]) == 2;
+}
+static int grs_cond_func_38684(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[4/* VProj1642 */]) == 3;
+}
+
+static void *grs_eval_out_func_38759(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[9/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_38762(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[10/* VProj9 */], 0);
+  return(NULL);
+}
+/* functions for building the pattern of action add_horz_4_32_variant0 */
+static _inline ext_grs_action_t *grs_action_add_horz_4_32_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "add_horz_4_32_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 0);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 1);
+    ext_grs_node_t *n_Vector_Result0_Add1643 = ext_grs_act_add_node(pattern, "Vector_Result0_Add1643", grs_op_Add, mode_F, 2);
+    ext_grs_node_t *n_VProj1616 = ext_grs_act_add_node(pattern, "VProj1616", grs_op_VProj, mode_F, 3);
+    ext_grs_node_t *n_VProj1642 = ext_grs_act_add_node(pattern, "VProj1642", grs_op_VProj, mode_F, 4);
+    ext_grs_node_t *n_VProj1633 = ext_grs_act_add_node(pattern, "VProj1633", grs_op_VProj, mode_F, 5);
+    ext_grs_node_t *n_VProj1624 = ext_grs_act_add_node(pattern, "VProj1624", grs_op_VProj, mode_F, 6);
+    ext_grs_node_t *n_Add1625 = ext_grs_act_add_node(pattern, "Add1625", grs_op_Add, mode_F, 7);
+    ext_grs_node_t *n_Add1634 = ext_grs_act_add_node(pattern, "Add1634", grs_op_Add, mode_F, 8);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos0_16 = ext_grs_act_add_edge(pattern, "pos0_16", -1, n_Vector_op_Block, n_Add1625, 0);
+    ext_grs_edge_t *e_e10 = ext_grs_act_add_edge(pattern, "e10", ext_grs_NO_EDGE_POS, n_VProj1642, n_Vector_Result0_Add1643, 1);
+    ext_grs_edge_t *e_e11 = ext_grs_act_add_edge(pattern, "e11", ext_grs_NO_EDGE_POS, n_Add1634, n_Vector_Result0_Add1643, 2);
+    ext_grs_edge_t *e_pos0_12 = ext_grs_act_add_edge(pattern, "pos0_12", -1, n_Vector_op_Block, n_Add1634, 3);
+    ext_grs_edge_t *e_e13 = ext_grs_act_add_edge(pattern, "e13", ext_grs_NO_EDGE_POS, n_VProj1633, n_Add1634, 4);
+    ext_grs_edge_t *e_pos1_20 = ext_grs_act_add_edge(pattern, "pos1_20", 0, n_Arg_0, n_VProj1633, 5);
+    ext_grs_edge_t *e_e14 = ext_grs_act_add_edge(pattern, "e14", ext_grs_NO_EDGE_POS, n_Add1625, n_Add1634, 6);
+    ext_grs_edge_t *e_pos1_21 = ext_grs_act_add_edge(pattern, "pos1_21", 0, n_Arg_0, n_VProj1642, 7);
+    ext_grs_edge_t *e_pos1_15 = ext_grs_act_add_edge(pattern, "pos1_15", 0, n_Arg_0, n_VProj1624, 8);
+    ext_grs_edge_t *e_pos1_19 = ext_grs_act_add_edge(pattern, "pos1_19", 0, n_Arg_0, n_VProj1616, 9);
+    ext_grs_edge_t *e_pos0_9 = ext_grs_act_add_edge(pattern, "pos0_9", -1, n_Vector_op_Block, n_Vector_Result0_Add1643, 10);
+    ext_grs_edge_t *e_e18 = ext_grs_act_add_edge(pattern, "e18", ext_grs_NO_EDGE_POS, n_VProj1616, n_Add1625, 11);
+    ext_grs_edge_t *e_e17 = ext_grs_act_add_edge(pattern, "e17", ext_grs_NO_EDGE_POS, n_VProj1624, n_Add1625, 12);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1624};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38675, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1616};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38678, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1633};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38681, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1642};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38684, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Arg_0_0 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_0", grs_op_VectorBase, mode_ANY, 0, n_Arg_0);
+       ext_grs_node_t *n_Vector_op_Block_1 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1", grs_op_Block, mode_BB, 1, n_Vector_op_Block);
+       ext_grs_node_t *n_VProj1616_2 = ext_grs_act_add_node_to_keep(pattern, "VProj1616_2", grs_op_VProj, mode_F, 3, n_VProj1616);
+       ext_grs_node_t *n_VProj1642_3 = ext_grs_act_add_node_to_keep(pattern, "VProj1642_3", grs_op_VProj, mode_F, 4, n_VProj1642);
+       ext_grs_node_t *n_VProj1633_4 = ext_grs_act_add_node_to_keep(pattern, "VProj1633_4", grs_op_VProj, mode_F, 5, n_VProj1633);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 9);
+       ext_grs_node_t *n_Add1634_5 = ext_grs_act_add_node_to_keep(pattern, "Add1634_5", grs_op_Add, mode_F, 8, n_Add1634);
+       ext_grs_node_t *n_VProj9_6 = ext_grs_act_add_node_to_keep(pattern, "VProj9_6", grs_op_VProj, mode_F, 10, n_Vector_Result0_Add1643);
+       ext_grs_node_t *n_VProj1624_7 = ext_grs_act_add_node_to_keep(pattern, "VProj1624_7", grs_op_VProj, mode_F, 6, n_VProj1624);
+       ext_grs_node_t *n_Add1625_8 = ext_grs_act_add_node_to_keep(pattern, "Add1625_8", grs_op_Add, mode_F, 7, n_Add1625);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 11);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos0_16_9 = ext_grs_act_add_edge_to_keep(pattern, "pos0_16_9", -1, n_Vector_op_Block_1, n_Add1625_8, 0, e_pos0_16);
+       ext_grs_edge_t *e_pos0_12_10 = ext_grs_act_add_edge_to_keep(pattern, "pos0_12_10", -1, n_Vector_op_Block_1, n_Add1634_5, 3, e_pos0_12);
+       ext_grs_edge_t *e_e13_11 = ext_grs_act_add_edge_to_keep(pattern, "e13_11", ext_grs_NO_EDGE_POS, n_VProj1633_4, n_Add1634_5, 4, e_e13);
+       ext_grs_edge_t *e_e14_12 = ext_grs_act_add_edge_to_keep(pattern, "e14_12", ext_grs_NO_EDGE_POS, n_Add1625_8, n_Add1634_5, 6, e_e14);
+       ext_grs_edge_t *e_pos1_15_13 = ext_grs_act_add_edge_to_keep(pattern, "pos1_15_13", 0, n_Arg_0_0, n_VProj1624_7, 8, e_pos1_15);
+       ext_grs_edge_t *e_pos1_19_14 = ext_grs_act_add_edge_to_keep(pattern, "pos1_19_14", 0, n_Arg_0_0, n_VProj1616_2, 9, e_pos1_19);
+       ext_grs_edge_t *e_pos0_9_15 = ext_grs_act_add_edge_to_keep(pattern, "pos0_9_15", -1, n_Vector_op_Block_1, n_VProj9_6, 10, e_pos0_9);
+       ext_grs_edge_t *e_e18_16 = ext_grs_act_add_edge_to_keep(pattern, "e18_16", ext_grs_NO_EDGE_POS, n_VProj1616_2, n_Add1625_8, 11, e_e18);
+       ext_grs_edge_t *e_e17_17 = ext_grs_act_add_edge_to_keep(pattern, "e17_17", ext_grs_NO_EDGE_POS, n_VProj1624_7, n_Add1625_8, 12, e_e17);
+       ext_grs_edge_t *e_pos0_23_18 = ext_grs_act_add_edge(pattern, "pos0_23_18", -1, n_Vector_op_Block_1, n_Vector_op_ProjData, 13);
+       ext_grs_edge_t *e_pos0_22_19 = ext_grs_act_add_edge(pattern, "pos0_22_19", -1, n_Vector_op_Block_1, n_Vector_op, 14);
+       ext_grs_edge_t *e_pos1_20_20 = ext_grs_act_add_edge_to_keep(pattern, "pos1_20_20", 0, n_Arg_0_0, n_VProj1633_4, 5, e_pos1_20);
+       ext_grs_edge_t *e_pos1_21_21 = ext_grs_act_add_edge_to_keep(pattern, "pos1_21_21", 0, n_Arg_0_0, n_VProj1642_3, 7, e_pos1_21);
+       ext_grs_edge_t *e_pos1_24_22 = ext_grs_act_add_edge(pattern, "pos1_24_22", 0, n_Vector_op, n_Vector_op_ProjData, 15);
+       ext_grs_edge_t *e_pos1_25_23 = ext_grs_act_add_edge(pattern, "pos1_25_23", 0, n_Arg_0_0, n_Vector_op, 16);
+       ext_grs_edge_t *e_pos1_26_24 = ext_grs_act_add_edge(pattern, "pos1_26_24", 0, n_Vector_op_ProjData, n_VProj9_6, 17);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38759);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38762);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* add_horz_4_32_variant0 */
+
+
+/* functions for evaluation of conditions of action component_0Iu_variant0 */
+static int grs_cond_func_45702(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[1/* Vector_Result0_VProj4276 */]) == 0;
+}
+
+static void *grs_eval_out_func_45758(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[4/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_45761(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[3/* Proj3 */], 0);
+  return(NULL);
+}
+/* functions for building the pattern of action component_0Iu_variant0 */
+static _inline ext_grs_action_t *grs_action_component_0Iu_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "component_0Iu_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 0);
+    ext_grs_node_t *n_Vector_Result0_VProj4276 = ext_grs_act_add_node(pattern, "Vector_Result0_VProj4276", grs_op_VProj, mode_Is, 1);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos0_3 = ext_grs_act_add_edge(pattern, "pos0_3", -1, n_Vector_op_Block, n_Vector_Result0_VProj4276, 0);
+    ext_grs_edge_t *e_pos1_4 = ext_grs_act_add_edge(pattern, "pos1_4", 0, n_Arg_0, n_Vector_Result0_VProj4276, 1);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_VProj4276};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45702, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Proj3_25 = ext_grs_act_add_node_to_keep(pattern, "Proj3_25", grs_op_Proj, mode_Is, 3, n_Vector_Result0_VProj4276);
+       ext_grs_node_t *n_Arg_0_26 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_26", grs_op_VectorBase, mode_ANY, 0, n_Arg_0);
+       ext_grs_node_t *n_Vector_op_Block_27 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_27", grs_op_Block, mode_BB, 2, n_Vector_op_Block);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 4);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 5);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos0_3_28 = ext_grs_act_add_edge_to_keep(pattern, "pos0_3_28", -1, n_Vector_op_Block_27, n_Proj3_25, 0, e_pos0_3);
+       ext_grs_edge_t *e_pos0_5_29 = ext_grs_act_add_edge(pattern, "pos0_5_29", -1, n_Vector_op_Block_27, n_Vector_op, 2);
+       ext_grs_edge_t *e_pos0_6_30 = ext_grs_act_add_edge(pattern, "pos0_6_30", -1, n_Vector_op_Block_27, n_Vector_op_ProjData, 3);
+       ext_grs_edge_t *e_pos1_10_31 = ext_grs_act_add_edge(pattern, "pos1_10_31", 0, n_Vector_op, n_Proj3_25, 4);
+       ext_grs_edge_t *e_pos1_7_32 = ext_grs_act_add_edge(pattern, "pos1_7_32", 0, n_Vector_op, n_Vector_op_ProjData, 5);
+       ext_grs_edge_t *e_pos1_8_33 = ext_grs_act_add_edge(pattern, "pos1_8_33", 0, n_Arg_0_26, n_Vector_op, 6);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_45758);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_45761);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* component_0Iu_variant0 */
+
+
+/* functions for evaluation of conditions of action component_0f_variant0 */
+static int grs_cond_func_45608(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[2/* Vector_Result0_VProj4149 */]) == 0;
+}
+
+static void *grs_eval_out_func_45664(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[4/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_45667(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[3/* Proj3 */], 0);
+  return(NULL);
+}
+/* functions for building the pattern of action component_0f_variant0 */
+static _inline ext_grs_action_t *grs_action_component_0f_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "component_0f_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 0);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 1);
+    ext_grs_node_t *n_Vector_Result0_VProj4149 = ext_grs_act_add_node(pattern, "Vector_Result0_VProj4149", grs_op_VProj, mode_F, 2);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos0_3 = ext_grs_act_add_edge(pattern, "pos0_3", -1, n_Vector_op_Block, n_Vector_Result0_VProj4149, 0);
+    ext_grs_edge_t *e_pos1_4 = ext_grs_act_add_edge(pattern, "pos1_4", 0, n_Arg_0, n_Vector_Result0_VProj4149, 1);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_VProj4149};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45608, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Arg_0_34 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_34", grs_op_VectorBase, mode_ANY, 0, n_Arg_0);
+       ext_grs_node_t *n_Vector_op_Block_35 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_35", grs_op_Block, mode_BB, 1, n_Vector_op_Block);
+       ext_grs_node_t *n_Proj3_36 = ext_grs_act_add_node_to_keep(pattern, "Proj3_36", grs_op_Proj, mode_F, 3, n_Vector_Result0_VProj4149);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 4);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 5);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos0_3_37 = ext_grs_act_add_edge_to_keep(pattern, "pos0_3_37", -1, n_Vector_op_Block_35, n_Proj3_36, 0, e_pos0_3);
+       ext_grs_edge_t *e_pos0_5_38 = ext_grs_act_add_edge(pattern, "pos0_5_38", -1, n_Vector_op_Block_35, n_Vector_op, 2);
+       ext_grs_edge_t *e_pos0_6_39 = ext_grs_act_add_edge(pattern, "pos0_6_39", -1, n_Vector_op_Block_35, n_Vector_op_ProjData, 3);
+       ext_grs_edge_t *e_pos1_10_40 = ext_grs_act_add_edge(pattern, "pos1_10_40", 0, n_Vector_op, n_Proj3_36, 4);
+       ext_grs_edge_t *e_pos1_7_41 = ext_grs_act_add_edge(pattern, "pos1_7_41", 0, n_Vector_op, n_Vector_op_ProjData, 5);
+       ext_grs_edge_t *e_pos1_8_42 = ext_grs_act_add_edge(pattern, "pos1_8_42", 0, n_Arg_0_34, n_Vector_op, 6);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_45664);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_45667);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* component_0f_variant0 */
+
+
+/* functions for evaluation of conditions of action maxps_variant0 */
+static int grs_cond_func_39331(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[1/* Proj1921 */]) == 1;
+}
+static int grs_cond_func_39334(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[30/* Proj2032 */]) == 0;
+}
+static int grs_cond_func_39337(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[32/* VProj2018 */]) == 2;
+}
+static int grs_cond_func_39340(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[36/* e68 */]) == get_edge_src_pos(edge_map[9/* e80 */]);
+}
+static int grs_cond_func_39343(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[35/* e69 */]) == get_edge_src_pos(edge_map[8/* e81 */]);
+}
+static int grs_cond_func_39346(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[54/* Proj2029 */]) == 4;
+}
+static int grs_cond_func_39349(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[31/* Proj2031 */]) == 1;
+}
+static int grs_cond_func_39352(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[21/* VProj2027 */]) == 2;
+}
+static int grs_cond_func_39355(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[44/* Proj2139 */]) == 4;
+}
+static int grs_cond_func_39358(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[2/* Proj1922 */]) == 0;
+}
+static int grs_cond_func_39361(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[6/* VProj2137 */]) == 3;
+}
+static int grs_cond_func_39364(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[40/* VProj1814 */]) == 0;
+}
+static int grs_cond_func_39367(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[48/* Proj1825 */]) == 4;
+}
+static int grs_cond_func_39370(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[51/* Proj1827 */]) == 1;
+}
+static int grs_cond_func_39373(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[40/* e101 */]) == get_edge_src_pos(edge_map[21/* e110 */]);
+}
+static int grs_cond_func_39376(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[39/* e102 */]) == get_edge_src_pos(edge_map[19/* e111 */]);
+}
+static int grs_cond_func_39379(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[49/* e104 */]) == get_edge_src_pos(edge_map[64/* e90 */]);
+}
+static int grs_cond_func_39382(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[47/* e105 */]) == get_edge_src_pos(edge_map[69/* e91 */]);
+}
+static int grs_cond_func_39385(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[3/* Proj2141 */]) == 1;
+}
+static int grs_cond_func_39388(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[20/* VProj1823 */]) == 0;
+}
+static int grs_cond_func_39391(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[7/* Proj1919 */]) == 4;
+}
+static int grs_cond_func_39394(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[52/* Proj1828 */]) == 0;
+}
+static int grs_cond_func_39397(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[28/* VProj1917 */]) == 1;
+}
+static int grs_cond_func_39400(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[19/* VProj2128 */]) == 3;
+}
+static int grs_cond_func_39403(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[28/* e119 */]) == get_edge_src_pos(edge_map[34/* e65 */]);
+}
+static int grs_cond_func_39406(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[10/* e120 */]) == get_edge_src_pos(edge_map[38/* e66 */]);
+}
+static int grs_cond_func_39409(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[4/* Proj2142 */]) == 0;
+}
+static int grs_cond_func_39412(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[47/* VProj1908 */]) == 1;
+}
+
+static void *grs_eval_out_func_39651(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[59/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_39654(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[57/* VProj55 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_39657(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[60/* VProj57 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_39660(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[56/* VProj59 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_39663(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[55/* VProj61 */], 1);
+  return(NULL);
+}
+/* functions for building the pattern of action maxps_variant0 */
+static _inline ext_grs_action_t *grs_action_maxps_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "maxps_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Vector_Result1_Phi4810 = ext_grs_act_add_node(pattern, "Vector_Result1_Phi4810", grs_op_Phi, mode_F, 0);
+    ext_grs_node_t *n_Proj1921 = ext_grs_act_add_node(pattern, "Proj1921", grs_op_Proj, mode_X, 1);
+    ext_grs_node_t *n_Proj1922 = ext_grs_act_add_node(pattern, "Proj1922", grs_op_Proj, mode_X, 2);
+    ext_grs_node_t *n_Proj2141 = ext_grs_act_add_node(pattern, "Proj2141", grs_op_Proj, mode_X, 3);
+    ext_grs_node_t *n_Proj2142 = ext_grs_act_add_node(pattern, "Proj2142", grs_op_Proj, mode_X, 4);
+    ext_grs_node_t *n_Vector_Result0_Phi4806 = ext_grs_act_add_node(pattern, "Vector_Result0_Phi4806", grs_op_Phi, mode_F, 5);
+    ext_grs_node_t *n_VProj2137 = ext_grs_act_add_node(pattern, "VProj2137", grs_op_VProj, mode_F, 6);
+    ext_grs_node_t *n_Proj1919 = ext_grs_act_add_node(pattern, "Proj1919", grs_op_Proj, mode_b, 7);
+    ext_grs_node_t *n_Jmp5768 = ext_grs_act_add_node(pattern, "Jmp5768", grs_op_Jmp, mode_X, 8);
+    ext_grs_node_t *n_Cond2140 = ext_grs_act_add_node(pattern, "Cond2140", grs_op_Cond, mode_T, 9);
+    ext_grs_node_t *n_Jmp5766 = ext_grs_act_add_node(pattern, "Jmp5766", grs_op_Jmp, mode_X, 10);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 11);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 12);
+    ext_grs_node_t *n_Jmp5770 = ext_grs_act_add_node(pattern, "Jmp5770", grs_op_Jmp, mode_X, 13);
+    ext_grs_node_t *n_Jmp2160 = ext_grs_act_add_node(pattern, "Jmp2160", grs_op_Jmp, mode_X, 14);
+    ext_grs_node_t *n_Cond1826 = ext_grs_act_add_node(pattern, "Cond1826", grs_op_Cond, mode_T, 15);
+    ext_grs_node_t *n_Cond1920 = ext_grs_act_add_node(pattern, "Cond1920", grs_op_Cond, mode_T, 16);
+    ext_grs_node_t *n_Block2008 = ext_grs_act_add_node(pattern, "Block2008", grs_op_Block, mode_BB, 17);
+    ext_grs_node_t *n_Block2006 = ext_grs_act_add_node(pattern, "Block2006", grs_op_Block, mode_BB, 18);
+    ext_grs_node_t *n_VProj2128 = ext_grs_act_add_node(pattern, "VProj2128", grs_op_VProj, mode_F, 19);
+    ext_grs_node_t *n_VProj1823 = ext_grs_act_add_node(pattern, "VProj1823", grs_op_VProj, mode_F, 20);
+    ext_grs_node_t *n_VProj2027 = ext_grs_act_add_node(pattern, "VProj2027", grs_op_VProj, mode_F, 21);
+    ext_grs_node_t *n_Jmp5772 = ext_grs_act_add_node(pattern, "Jmp5772", grs_op_Jmp, mode_X, 22);
+    ext_grs_node_t *n_Vector_Result3_Phi4818 = ext_grs_act_add_node(pattern, "Vector_Result3_Phi4818", grs_op_Phi, mode_F, 23);
+    ext_grs_node_t *n_Block4800 = ext_grs_act_add_node(pattern, "Block4800", grs_op_Block, mode_BB, 24);
+    ext_grs_node_t *n_Jmp1974 = ext_grs_act_add_node(pattern, "Jmp1974", grs_op_Jmp, mode_X, 25);
+    ext_grs_node_t *n_Block5771 = ext_grs_act_add_node(pattern, "Block5771", grs_op_Block, mode_BB, 26);
+    ext_grs_node_t *n_Cond2030 = ext_grs_act_add_node(pattern, "Cond2030", grs_op_Cond, mode_T, 27);
+    ext_grs_node_t *n_VProj1917 = ext_grs_act_add_node(pattern, "VProj1917", grs_op_VProj, mode_F, 28);
+    ext_grs_node_t *n_Block2117 = ext_grs_act_add_node(pattern, "Block2117", grs_op_Block, mode_BB, 29);
+    ext_grs_node_t *n_Proj2032 = ext_grs_act_add_node(pattern, "Proj2032", grs_op_Proj, mode_X, 30);
+    ext_grs_node_t *n_Proj2031 = ext_grs_act_add_node(pattern, "Proj2031", grs_op_Proj, mode_X, 31);
+    ext_grs_node_t *n_VProj2018 = ext_grs_act_add_node(pattern, "VProj2018", grs_op_VProj, mode_F, 32);
+    ext_grs_node_t *n_Cmp5663 = ext_grs_act_add_node(pattern, "Cmp5663", grs_op_Cmp, mode_T, 33);
+    ext_grs_node_t *n_Vector_Result2_Phi4814 = ext_grs_act_add_node(pattern, "Vector_Result2_Phi4814", grs_op_Phi, mode_F, 34);
+    ext_grs_node_t *n_Cmp5664 = ext_grs_act_add_node(pattern, "Cmp5664", grs_op_Cmp, mode_T, 35);
+    ext_grs_node_t *n_Cmp5665 = ext_grs_act_add_node(pattern, "Cmp5665", grs_op_Cmp, mode_T, 36);
+    ext_grs_node_t *n_Block1896 = ext_grs_act_add_node(pattern, "Block1896", grs_op_Block, mode_BB, 37);
+    ext_grs_node_t *n_Cmp5666 = ext_grs_act_add_node(pattern, "Cmp5666", grs_op_Cmp, mode_T, 38);
+    ext_grs_node_t *n_Block1898 = ext_grs_act_add_node(pattern, "Block1898", grs_op_Block, mode_BB, 39);
+    ext_grs_node_t *n_VProj1814 = ext_grs_act_add_node(pattern, "VProj1814", grs_op_VProj, mode_F, 40);
+    ext_grs_node_t *n_Block5769 = ext_grs_act_add_node(pattern, "Block5769", grs_op_Block, mode_BB, 41);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 42);
+    ext_grs_node_t *n_Jmp2084 = ext_grs_act_add_node(pattern, "Jmp2084", grs_op_Jmp, mode_X, 43);
+    ext_grs_node_t *n_Proj2139 = ext_grs_act_add_node(pattern, "Proj2139", grs_op_Proj, mode_b, 44);
+    ext_grs_node_t *n_Block5765 = ext_grs_act_add_node(pattern, "Block5765", grs_op_Block, mode_BB, 45);
+    ext_grs_node_t *n_Block5767 = ext_grs_act_add_node(pattern, "Block5767", grs_op_Block, mode_BB, 46);
+    ext_grs_node_t *n_VProj1908 = ext_grs_act_add_node(pattern, "VProj1908", grs_op_VProj, mode_F, 47);
+    ext_grs_node_t *n_Proj1825 = ext_grs_act_add_node(pattern, "Proj1825", grs_op_Proj, mode_b, 48);
+    ext_grs_node_t *n_Block1804 = ext_grs_act_add_node(pattern, "Block1804", grs_op_Block, mode_BB, 49);
+    ext_grs_node_t *n_Jmp1864 = ext_grs_act_add_node(pattern, "Jmp1864", grs_op_Jmp, mode_X, 50);
+    ext_grs_node_t *n_Proj1827 = ext_grs_act_add_node(pattern, "Proj1827", grs_op_Proj, mode_X, 51);
+    ext_grs_node_t *n_Proj1828 = ext_grs_act_add_node(pattern, "Proj1828", grs_op_Proj, mode_X, 52);
+    ext_grs_node_t *n_Block1802 = ext_grs_act_add_node(pattern, "Block1802", grs_op_Block, mode_BB, 53);
+    ext_grs_node_t *n_Proj2029 = ext_grs_act_add_node(pattern, "Proj2029", grs_op_Proj, mode_b, 54);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e78 = ext_grs_act_add_edge(pattern, "e78", ext_grs_NO_EDGE_POS, n_Proj1922, n_Block1896, 0);
+    ext_grs_edge_t *e_e73 = ext_grs_act_add_edge(pattern, "e73", ext_grs_NO_EDGE_POS, n_Proj1921, n_Block5767, 1);
+    ext_grs_edge_t *e_pos1_77 = ext_grs_act_add_edge(pattern, "pos1_77", 0, n_Arg_1, n_VProj2027, 2);
+    ext_grs_edge_t *e_pos1_79 = ext_grs_act_add_edge(pattern, "pos1_79", 0, n_Cmp5666, n_Proj2139, 3);
+    ext_grs_edge_t *e_pos1_72 = ext_grs_act_add_edge(pattern, "pos1_72", 0, n_Cond2030, n_Proj2031, 4);
+    ext_grs_edge_t *e_pos1_75 = ext_grs_act_add_edge(pattern, "pos1_75", 0, n_Proj2139, n_Cond2140, 5);
+    ext_grs_edge_t *e_pos1_70 = ext_grs_act_add_edge(pattern, "pos1_70", 0, n_Cmp5665, n_Proj2029, 6);
+    ext_grs_edge_t *e_e83 = ext_grs_act_add_edge(pattern, "e83", ext_grs_NO_EDGE_POS, n_Proj2031, n_Block5769, 7);
+    ext_grs_edge_t *e_e81 = ext_grs_act_add_edge(pattern, "e81", ext_grs_NO_EDGE_POS, n_Jmp2160, n_Block4800, 8);
+    ext_grs_edge_t *e_e80 = ext_grs_act_add_edge(pattern, "e80", ext_grs_NO_EDGE_POS, n_Jmp5772, n_Block4800, 9);
+    ext_grs_edge_t *e_e120 = ext_grs_act_add_edge(pattern, "e120", ext_grs_NO_EDGE_POS, n_VProj1908, n_Vector_Result1_Phi4810, 10);
+    ext_grs_edge_t *e_pos1_89 = ext_grs_act_add_edge(pattern, "pos1_89", 0, n_Arg_0, n_VProj1814, 11);
+    ext_grs_edge_t *e_e121 = ext_grs_act_add_edge(pattern, "e121", ext_grs_NO_EDGE_POS, n_Proj2032, n_Block2006, 12);
+    ext_grs_edge_t *e_pos1_87 = ext_grs_act_add_edge(pattern, "pos1_87", 0, n_Proj1825, n_Cond1826, 13);
+    ext_grs_edge_t *e_pos0_113 = ext_grs_act_add_edge(pattern, "pos0_113", -1, n_Vector_op_Block, n_Proj1828, 14);
+    ext_grs_edge_t *e_pos0_112 = ext_grs_act_add_edge(pattern, "pos0_112", -1, n_Block5771, n_Jmp5772, 15);
+    ext_grs_edge_t *e_pos1_85 = ext_grs_act_add_edge(pattern, "pos1_85", 0, n_Arg_1, n_VProj2137, 16);
+    ext_grs_edge_t *e_pos1_84 = ext_grs_act_add_edge(pattern, "pos1_84", 0, n_Cond1920, n_Proj1922, 17);
+    ext_grs_edge_t *e_pos0_117 = ext_grs_act_add_edge(pattern, "pos0_117", -1, n_Block2006, n_Jmp2084, 18);
+    ext_grs_edge_t *e_e111 = ext_grs_act_add_edge(pattern, "e111", ext_grs_NO_EDGE_POS, n_Jmp2084, n_Block2008, 19);
+    ext_grs_edge_t *e_pos1_55 = ext_grs_act_add_edge(pattern, "pos1_55", 0, n_Cond1920, n_Proj1921, 20);
+    ext_grs_edge_t *e_e110 = ext_grs_act_add_edge(pattern, "e110", ext_grs_NO_EDGE_POS, n_Jmp5770, n_Block2008, 21);
+    ext_grs_edge_t *e_pos2_59 = ext_grs_act_add_edge(pattern, "pos2_59", 1, n_VProj2128, n_Cmp5666, 22);
+    ext_grs_edge_t *e_pos1_56 = ext_grs_act_add_edge(pattern, "pos1_56", 0, n_VProj1917, n_Cmp5664, 23);
+    ext_grs_edge_t *e_pos2_57 = ext_grs_act_add_edge(pattern, "pos2_57", 1, n_VProj1908, n_Cmp5664, 24);
+    ext_grs_edge_t *e_pos0_97 = ext_grs_act_add_edge(pattern, "pos0_97", -1, n_Block1804, n_Cond1920, 25);
+    ext_grs_edge_t *e_pos1_58 = ext_grs_act_add_edge(pattern, "pos1_58", 0, n_VProj2137, n_Cmp5666, 26);
+    ext_grs_edge_t *e_pos0_99 = ext_grs_act_add_edge(pattern, "pos0_99", -1, n_Block1802, n_Jmp1864, 27);
+    ext_grs_edge_t *e_e119 = ext_grs_act_add_edge(pattern, "e119", ext_grs_NO_EDGE_POS, n_VProj1917, n_Vector_Result1_Phi4810, 28);
+    ext_grs_edge_t *e_pos0_94 = ext_grs_act_add_edge(pattern, "pos0_94", -1, n_Block5769, n_Jmp5770, 29);
+    ext_grs_edge_t *e_e118 = ext_grs_act_add_edge(pattern, "e118", ext_grs_NO_EDGE_POS, n_Block1898, n_Vector_Result1_Phi4810, 30);
+    ext_grs_edge_t *e_pos2_125 = ext_grs_act_add_edge(pattern, "pos2_125", 1, n_VProj1814, n_Cmp5663, 31);
+    ext_grs_edge_t *e_pos2_127 = ext_grs_act_add_edge(pattern, "pos2_127", 1, n_VProj2018, n_Cmp5665, 32);
+    ext_grs_edge_t *e_e60 = ext_grs_act_add_edge(pattern, "e60", ext_grs_NO_EDGE_POS, n_Proj1827, n_Block5765, 33);
+    ext_grs_edge_t *e_e65 = ext_grs_act_add_edge(pattern, "e65", ext_grs_NO_EDGE_POS, n_Jmp5768, n_Block1898, 34);
+    ext_grs_edge_t *e_e69 = ext_grs_act_add_edge(pattern, "e69", ext_grs_NO_EDGE_POS, n_VProj2137, n_Vector_Result3_Phi4818, 35);
+    ext_grs_edge_t *e_e68 = ext_grs_act_add_edge(pattern, "e68", ext_grs_NO_EDGE_POS, n_VProj2128, n_Vector_Result3_Phi4818, 36);
+    ext_grs_edge_t *e_e67 = ext_grs_act_add_edge(pattern, "e67", ext_grs_NO_EDGE_POS, n_Block4800, n_Vector_Result3_Phi4818, 37);
+    ext_grs_edge_t *e_e66 = ext_grs_act_add_edge(pattern, "e66", ext_grs_NO_EDGE_POS, n_Jmp1974, n_Block1898, 38);
+    ext_grs_edge_t *e_e102 = ext_grs_act_add_edge(pattern, "e102", ext_grs_NO_EDGE_POS, n_VProj2018, n_Vector_Result2_Phi4814, 39);
+    ext_grs_edge_t *e_e101 = ext_grs_act_add_edge(pattern, "e101", ext_grs_NO_EDGE_POS, n_VProj2027, n_Vector_Result2_Phi4814, 40);
+    ext_grs_edge_t *e_e100 = ext_grs_act_add_edge(pattern, "e100", ext_grs_NO_EDGE_POS, n_Block2008, n_Vector_Result2_Phi4814, 41);
+    ext_grs_edge_t *e_pos0_88 = ext_grs_act_add_edge(pattern, "pos0_88", -1, n_Block2117, n_Jmp2160, 42);
+    ext_grs_edge_t *e_pos0_86 = ext_grs_act_add_edge(pattern, "pos0_86", -1, n_Vector_op_Block, n_Cond1826, 43);
+    ext_grs_edge_t *e_e109 = ext_grs_act_add_edge(pattern, "e109", ext_grs_NO_EDGE_POS, n_Proj1828, n_Block1802, 44);
+    ext_grs_edge_t *e_pos0_82 = ext_grs_act_add_edge(pattern, "pos0_82", -1, n_Block5767, n_Jmp5768, 45);
+    ext_grs_edge_t *e_pos1_64 = ext_grs_act_add_edge(pattern, "pos1_64", 0, n_Arg_0, n_VProj2018, 46);
+    ext_grs_edge_t *e_e105 = ext_grs_act_add_edge(pattern, "e105", ext_grs_NO_EDGE_POS, n_VProj1814, n_Vector_Result0_Phi4806, 47);
+    ext_grs_edge_t *e_pos1_63 = ext_grs_act_add_edge(pattern, "pos1_63", 0, n_Proj2029, n_Cond2030, 48);
+    ext_grs_edge_t *e_e104 = ext_grs_act_add_edge(pattern, "e104", ext_grs_NO_EDGE_POS, n_VProj1823, n_Vector_Result0_Phi4806, 49);
+    ext_grs_edge_t *e_e103 = ext_grs_act_add_edge(pattern, "e103", ext_grs_NO_EDGE_POS, n_Block1804, n_Vector_Result0_Phi4806, 50);
+    ext_grs_edge_t *e_pos1_61 = ext_grs_act_add_edge(pattern, "pos1_61", 0, n_Cond2030, n_Proj2032, 51);
+    ext_grs_edge_t *e_pos1_108 = ext_grs_act_add_edge(pattern, "pos1_108", 0, n_Cmp5664, n_Proj1919, 52);
+    ext_grs_edge_t *e_pos0_74 = ext_grs_act_add_edge(pattern, "pos0_74", -1, n_Block2008, n_Cond2140, 53);
+    ext_grs_edge_t *e_pos0_71 = ext_grs_act_add_edge(pattern, "pos0_71", -1, n_Block5765, n_Jmp5766, 54);
+    ext_grs_edge_t *e_pos0_76 = ext_grs_act_add_edge(pattern, "pos0_76", -1, n_Block1896, n_Jmp1974, 55);
+    ext_grs_edge_t *e_pos1_106 = ext_grs_act_add_edge(pattern, "pos1_106", 0, n_Arg_1, n_VProj1823, 56);
+    ext_grs_edge_t *e_pos1_107 = ext_grs_act_add_edge(pattern, "pos1_107", 0, n_Cond2140, n_Proj2141, 57);
+    ext_grs_edge_t *e_pos0_62 = ext_grs_act_add_edge(pattern, "pos0_62", -1, n_Block1898, n_Cond2030, 58);
+    ext_grs_edge_t *e_pos1_92 = ext_grs_act_add_edge(pattern, "pos1_92", 0, n_Cmp5663, n_Proj1825, 59);
+    ext_grs_edge_t *e_e96 = ext_grs_act_add_edge(pattern, "e96", ext_grs_NO_EDGE_POS, n_Proj2142, n_Block5771, 60);
+    ext_grs_edge_t *e_pos1_95 = ext_grs_act_add_edge(pattern, "pos1_95", 0, n_Cond1826, n_Proj1827, 61);
+    ext_grs_edge_t *e_pos1_126 = ext_grs_act_add_edge(pattern, "pos1_126", 0, n_VProj2027, n_Cmp5665, 62);
+    ext_grs_edge_t *e_pos1_98 = ext_grs_act_add_edge(pattern, "pos1_98", 0, n_Proj1919, n_Cond1920, 63);
+    ext_grs_edge_t *e_e90 = ext_grs_act_add_edge(pattern, "e90", ext_grs_NO_EDGE_POS, n_Jmp5766, n_Block1804, 64);
+    ext_grs_edge_t *e_pos1_122 = ext_grs_act_add_edge(pattern, "pos1_122", 0, n_Cond2140, n_Proj2142, 65);
+    ext_grs_edge_t *e_e93 = ext_grs_act_add_edge(pattern, "e93", ext_grs_NO_EDGE_POS, n_Proj2141, n_Block2117, 66);
+    ext_grs_edge_t *e_pos1_123 = ext_grs_act_add_edge(pattern, "pos1_123", 0, n_Arg_0, n_VProj1908, 67);
+    ext_grs_edge_t *e_pos1_124 = ext_grs_act_add_edge(pattern, "pos1_124", 0, n_VProj1823, n_Cmp5663, 68);
+    ext_grs_edge_t *e_e91 = ext_grs_act_add_edge(pattern, "e91", ext_grs_NO_EDGE_POS, n_Jmp1864, n_Block1804, 69);
+    ext_grs_edge_t *e_pos1_115 = ext_grs_act_add_edge(pattern, "pos1_115", 0, n_Arg_1, n_VProj1917, 70);
+    ext_grs_edge_t *e_pos1_116 = ext_grs_act_add_edge(pattern, "pos1_116", 0, n_Arg_0, n_VProj2128, 71);
+    ext_grs_edge_t *e_pos1_114 = ext_grs_act_add_edge(pattern, "pos1_114", 0, n_Cond1826, n_Proj1828, 72);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1921};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39331, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2032};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39334, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2018};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39337, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e80, e_e68};
+
+      ext_grs_act_register_condition(grs_cond_func_39340, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e81, e_e69};
+
+      ext_grs_act_register_condition(grs_cond_func_39343, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2029};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39346, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2031};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39349, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2027};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39352, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2139};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39355, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1922};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39358, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2137};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39361, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1814};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39364, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1825};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39367, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1827};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39370, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e110, e_e101};
+
+      ext_grs_act_register_condition(grs_cond_func_39373, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e111, e_e102};
+
+      ext_grs_act_register_condition(grs_cond_func_39376, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e90, e_e104};
+
+      ext_grs_act_register_condition(grs_cond_func_39379, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e105, e_e91};
+
+      ext_grs_act_register_condition(grs_cond_func_39382, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2141};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39385, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1823};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39388, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1919};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39391, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1828};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39394, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1917};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39397, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2128};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39400, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e65, e_e119};
+
+      ext_grs_act_register_condition(grs_cond_func_39403, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e120, e_e66};
+
+      ext_grs_act_register_condition(grs_cond_func_39406, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2142};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39409, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1908};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_39412, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_VProj61_43 = ext_grs_act_add_node_to_keep(pattern, "VProj61_43", grs_op_VProj, mode_F, 55, n_Vector_Result1_Phi4810);
+       ext_grs_node_t *n_Proj1921_44 = ext_grs_act_add_node_to_keep(pattern, "Proj1921_44", grs_op_Proj, mode_X, 1, n_Proj1921);
+       ext_grs_node_t *n_Proj1922_45 = ext_grs_act_add_node_to_keep(pattern, "Proj1922_45", grs_op_Proj, mode_X, 2, n_Proj1922);
+       ext_grs_node_t *n_Proj2141_46 = ext_grs_act_add_node_to_keep(pattern, "Proj2141_46", grs_op_Proj, mode_X, 3, n_Proj2141);
+       ext_grs_node_t *n_Proj2142_47 = ext_grs_act_add_node_to_keep(pattern, "Proj2142_47", grs_op_Proj, mode_X, 4, n_Proj2142);
+       ext_grs_node_t *n_VProj59_48 = ext_grs_act_add_node_to_keep(pattern, "VProj59_48", grs_op_VProj, mode_F, 56, n_Vector_Result0_Phi4806);
+       ext_grs_node_t *n_Proj1919_49 = ext_grs_act_add_node_to_keep(pattern, "Proj1919_49", grs_op_Proj, mode_b, 7, n_Proj1919);
+       ext_grs_node_t *n_VProj2137_50 = ext_grs_act_add_node_to_keep(pattern, "VProj2137_50", grs_op_VProj, mode_F, 6, n_VProj2137);
+       ext_grs_node_t *n_Jmp5768_51 = ext_grs_act_add_node_to_keep(pattern, "Jmp5768_51", grs_op_Jmp, mode_X, 8, n_Jmp5768);
+       ext_grs_node_t *n_Cond2140_52 = ext_grs_act_add_node_to_keep(pattern, "Cond2140_52", grs_op_Cond, mode_T, 9, n_Cond2140);
+       ext_grs_node_t *n_Jmp5766_53 = ext_grs_act_add_node_to_keep(pattern, "Jmp5766_53", grs_op_Jmp, mode_X, 10, n_Jmp5766);
+       ext_grs_node_t *n_Arg_0_54 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_54", grs_op_VectorBase, mode_ANY, 11, n_Arg_0);
+       ext_grs_node_t *n_Arg_1_55 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_55", grs_op_VectorBase, mode_ANY, 12, n_Arg_1);
+       ext_grs_node_t *n_Jmp5770_56 = ext_grs_act_add_node_to_keep(pattern, "Jmp5770_56", grs_op_Jmp, mode_X, 13, n_Jmp5770);
+       ext_grs_node_t *n_Jmp2160_57 = ext_grs_act_add_node_to_keep(pattern, "Jmp2160_57", grs_op_Jmp, mode_X, 14, n_Jmp2160);
+       ext_grs_node_t *n_Cond1826_58 = ext_grs_act_add_node_to_keep(pattern, "Cond1826_58", grs_op_Cond, mode_T, 15, n_Cond1826);
+       ext_grs_node_t *n_Cond1920_59 = ext_grs_act_add_node_to_keep(pattern, "Cond1920_59", grs_op_Cond, mode_T, 16, n_Cond1920);
+       ext_grs_node_t *n_Block2008_60 = ext_grs_act_add_node_to_keep(pattern, "Block2008_60", grs_op_Block, mode_BB, 17, n_Block2008);
+       ext_grs_node_t *n_Block2006_61 = ext_grs_act_add_node_to_keep(pattern, "Block2006_61", grs_op_Block, mode_BB, 18, n_Block2006);
+       ext_grs_node_t *n_VProj2128_62 = ext_grs_act_add_node_to_keep(pattern, "VProj2128_62", grs_op_VProj, mode_F, 19, n_VProj2128);
+       ext_grs_node_t *n_VProj1823_63 = ext_grs_act_add_node_to_keep(pattern, "VProj1823_63", grs_op_VProj, mode_F, 20, n_VProj1823);
+       ext_grs_node_t *n_VProj2027_64 = ext_grs_act_add_node_to_keep(pattern, "VProj2027_64", grs_op_VProj, mode_F, 21, n_VProj2027);
+       ext_grs_node_t *n_Jmp5772_65 = ext_grs_act_add_node_to_keep(pattern, "Jmp5772_65", grs_op_Jmp, mode_X, 22, n_Jmp5772);
+       ext_grs_node_t *n_VProj55_66 = ext_grs_act_add_node_to_keep(pattern, "VProj55_66", grs_op_VProj, mode_F, 57, n_Vector_Result3_Phi4818);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 58);
+       ext_grs_node_t *n_Block4800_67 = ext_grs_act_add_node_to_keep(pattern, "Block4800_67", grs_op_Block, mode_BB, 24, n_Block4800);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 59);
+       ext_grs_node_t *n_Jmp1974_68 = ext_grs_act_add_node_to_keep(pattern, "Jmp1974_68", grs_op_Jmp, mode_X, 25, n_Jmp1974);
+       ext_grs_node_t *n_Block5771_69 = ext_grs_act_add_node_to_keep(pattern, "Block5771_69", grs_op_Block, mode_BB, 26, n_Block5771);
+       ext_grs_node_t *n_Cond2030_70 = ext_grs_act_add_node_to_keep(pattern, "Cond2030_70", grs_op_Cond, mode_T, 27, n_Cond2030);
+       ext_grs_node_t *n_VProj1917_71 = ext_grs_act_add_node_to_keep(pattern, "VProj1917_71", grs_op_VProj, mode_F, 28, n_VProj1917);
+       ext_grs_node_t *n_Block2117_72 = ext_grs_act_add_node_to_keep(pattern, "Block2117_72", grs_op_Block, mode_BB, 29, n_Block2117);
+       ext_grs_node_t *n_Proj2032_73 = ext_grs_act_add_node_to_keep(pattern, "Proj2032_73", grs_op_Proj, mode_X, 30, n_Proj2032);
+       ext_grs_node_t *n_Proj2031_74 = ext_grs_act_add_node_to_keep(pattern, "Proj2031_74", grs_op_Proj, mode_X, 31, n_Proj2031);
+       ext_grs_node_t *n_VProj2018_75 = ext_grs_act_add_node_to_keep(pattern, "VProj2018_75", grs_op_VProj, mode_F, 32, n_VProj2018);
+       ext_grs_node_t *n_VProj57_76 = ext_grs_act_add_node_to_keep(pattern, "VProj57_76", grs_op_VProj, mode_F, 60, n_Vector_Result2_Phi4814);
+       ext_grs_node_t *n_Cmp5663_77 = ext_grs_act_add_node_to_keep(pattern, "Cmp5663_77", grs_op_Cmp, mode_T, 33, n_Cmp5663);
+       ext_grs_node_t *n_Cmp5664_78 = ext_grs_act_add_node_to_keep(pattern, "Cmp5664_78", grs_op_Cmp, mode_T, 35, n_Cmp5664);
+       ext_grs_node_t *n_Cmp5665_79 = ext_grs_act_add_node_to_keep(pattern, "Cmp5665_79", grs_op_Cmp, mode_T, 36, n_Cmp5665);
+       ext_grs_node_t *n_Block1896_80 = ext_grs_act_add_node_to_keep(pattern, "Block1896_80", grs_op_Block, mode_BB, 37, n_Block1896);
+       ext_grs_node_t *n_Cmp5666_81 = ext_grs_act_add_node_to_keep(pattern, "Cmp5666_81", grs_op_Cmp, mode_T, 38, n_Cmp5666);
+       ext_grs_node_t *n_VProj1814_82 = ext_grs_act_add_node_to_keep(pattern, "VProj1814_82", grs_op_VProj, mode_F, 40, n_VProj1814);
+       ext_grs_node_t *n_Block1898_83 = ext_grs_act_add_node_to_keep(pattern, "Block1898_83", grs_op_Block, mode_BB, 39, n_Block1898);
+       ext_grs_node_t *n_Block5769_84 = ext_grs_act_add_node_to_keep(pattern, "Block5769_84", grs_op_Block, mode_BB, 41, n_Block5769);
+       ext_grs_node_t *n_Vector_op_Block_85 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_85", grs_op_Block, mode_BB, 42, n_Vector_op_Block);
+       ext_grs_node_t *n_Jmp2084_86 = ext_grs_act_add_node_to_keep(pattern, "Jmp2084_86", grs_op_Jmp, mode_X, 43, n_Jmp2084);
+       ext_grs_node_t *n_Proj2139_87 = ext_grs_act_add_node_to_keep(pattern, "Proj2139_87", grs_op_Proj, mode_b, 44, n_Proj2139);
+       ext_grs_node_t *n_Block5765_88 = ext_grs_act_add_node_to_keep(pattern, "Block5765_88", grs_op_Block, mode_BB, 45, n_Block5765);
+       ext_grs_node_t *n_Block5767_89 = ext_grs_act_add_node_to_keep(pattern, "Block5767_89", grs_op_Block, mode_BB, 46, n_Block5767);
+       ext_grs_node_t *n_VProj1908_90 = ext_grs_act_add_node_to_keep(pattern, "VProj1908_90", grs_op_VProj, mode_F, 47, n_VProj1908);
+       ext_grs_node_t *n_Proj1825_91 = ext_grs_act_add_node_to_keep(pattern, "Proj1825_91", grs_op_Proj, mode_b, 48, n_Proj1825);
+       ext_grs_node_t *n_Jmp1864_92 = ext_grs_act_add_node_to_keep(pattern, "Jmp1864_92", grs_op_Jmp, mode_X, 50, n_Jmp1864);
+       ext_grs_node_t *n_Block1804_93 = ext_grs_act_add_node_to_keep(pattern, "Block1804_93", grs_op_Block, mode_BB, 49, n_Block1804);
+       ext_grs_node_t *n_Proj1827_94 = ext_grs_act_add_node_to_keep(pattern, "Proj1827_94", grs_op_Proj, mode_X, 51, n_Proj1827);
+       ext_grs_node_t *n_Block1802_95 = ext_grs_act_add_node_to_keep(pattern, "Block1802_95", grs_op_Block, mode_BB, 53, n_Block1802);
+       ext_grs_node_t *n_Proj1828_96 = ext_grs_act_add_node_to_keep(pattern, "Proj1828_96", grs_op_Proj, mode_X, 52, n_Proj1828);
+       ext_grs_node_t *n_Proj2029_97 = ext_grs_act_add_node_to_keep(pattern, "Proj2029_97", grs_op_Proj, mode_b, 54, n_Proj2029);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_e78_98 = ext_grs_act_add_edge_to_keep(pattern, "e78_98", ext_grs_NO_EDGE_POS, n_Proj1922_45, n_Block1896_80, 0, e_e78);
+       ext_grs_edge_t *e_e73_99 = ext_grs_act_add_edge_to_keep(pattern, "e73_99", ext_grs_NO_EDGE_POS, n_Proj1921_44, n_Block5767_89, 1, e_e73);
+       ext_grs_edge_t *e_pos1_77_100 = ext_grs_act_add_edge_to_keep(pattern, "pos1_77_100", 0, n_Arg_1_55, n_VProj2027_64, 2, e_pos1_77);
+       ext_grs_edge_t *e_pos1_79_101 = ext_grs_act_add_edge_to_keep(pattern, "pos1_79_101", 0, n_Cmp5666_81, n_Proj2139_87, 3, e_pos1_79);
+       ext_grs_edge_t *e_pos1_72_102 = ext_grs_act_add_edge_to_keep(pattern, "pos1_72_102", 0, n_Cond2030_70, n_Proj2031_74, 4, e_pos1_72);
+       ext_grs_edge_t *e_pos1_75_103 = ext_grs_act_add_edge_to_keep(pattern, "pos1_75_103", 0, n_Proj2139_87, n_Cond2140_52, 5, e_pos1_75);
+       ext_grs_edge_t *e_pos0_129_104 = ext_grs_act_add_edge(pattern, "pos0_129_104", -1, n_Vector_op_Block_85, n_Vector_op_ProjData, 73);
+       ext_grs_edge_t *e_pos0_128_105 = ext_grs_act_add_edge(pattern, "pos0_128_105", -1, n_Vector_op_Block_85, n_Vector_op, 74);
+       ext_grs_edge_t *e_pos1_70_106 = ext_grs_act_add_edge_to_keep(pattern, "pos1_70_106", 0, n_Cmp5665_79, n_Proj2029_97, 6, e_pos1_70);
+       ext_grs_edge_t *e_pos1_134_107 = ext_grs_act_add_edge(pattern, "pos1_134_107", 0, n_Vector_op_ProjData, n_VProj57_76, 75);
+       ext_grs_edge_t *e_e83_108 = ext_grs_act_add_edge_to_keep(pattern, "e83_108", ext_grs_NO_EDGE_POS, n_Proj2031_74, n_Block5769_84, 7, e_e83);
+       ext_grs_edge_t *e_pos1_133_109 = ext_grs_act_add_edge(pattern, "pos1_133_109", 0, n_Vector_op_ProjData, n_VProj55_66, 76);
+       ext_grs_edge_t *e_pos1_136_110 = ext_grs_act_add_edge(pattern, "pos1_136_110", 0, n_Vector_op_ProjData, n_VProj61_43, 77);
+       ext_grs_edge_t *e_e81_111 = ext_grs_act_add_edge_to_keep(pattern, "e81_111", ext_grs_NO_EDGE_POS, n_Jmp2160_57, n_Block4800_67, 8, e_e81);
+       ext_grs_edge_t *e_pos1_135_112 = ext_grs_act_add_edge(pattern, "pos1_135_112", 0, n_Vector_op_ProjData, n_VProj59_48, 78);
+       ext_grs_edge_t *e_e80_113 = ext_grs_act_add_edge_to_keep(pattern, "e80_113", ext_grs_NO_EDGE_POS, n_Jmp5772_65, n_Block4800_67, 9, e_e80);
+       ext_grs_edge_t *e_pos1_130_114 = ext_grs_act_add_edge(pattern, "pos1_130_114", 0, n_Vector_op, n_Vector_op_ProjData, 79);
+       ext_grs_edge_t *e_pos1_132_115 = ext_grs_act_add_edge(pattern, "pos1_132_115", 0, n_Arg_0_54, n_Vector_op, 80);
+       ext_grs_edge_t *e_pos1_89_116 = ext_grs_act_add_edge_to_keep(pattern, "pos1_89_116", 0, n_Arg_0_54, n_VProj1814_82, 11, e_pos1_89);
+       ext_grs_edge_t *e_pos1_87_117 = ext_grs_act_add_edge_to_keep(pattern, "pos1_87_117", 0, n_Proj1825_91, n_Cond1826_58, 13, e_pos1_87);
+       ext_grs_edge_t *e_e121_118 = ext_grs_act_add_edge_to_keep(pattern, "e121_118", ext_grs_NO_EDGE_POS, n_Proj2032_73, n_Block2006_61, 12, e_e121);
+       ext_grs_edge_t *e_pos0_113_119 = ext_grs_act_add_edge_to_keep(pattern, "pos0_113_119", -1, n_Vector_op_Block_85, n_Proj1828_96, 14, e_pos0_113);
+       ext_grs_edge_t *e_pos1_85_120 = ext_grs_act_add_edge_to_keep(pattern, "pos1_85_120", 0, n_Arg_1_55, n_VProj2137_50, 16, e_pos1_85);
+       ext_grs_edge_t *e_pos0_112_121 = ext_grs_act_add_edge_to_keep(pattern, "pos0_112_121", -1, n_Block5771_69, n_Jmp5772_65, 15, e_pos0_112);
+       ext_grs_edge_t *e_pos1_84_122 = ext_grs_act_add_edge_to_keep(pattern, "pos1_84_122", 0, n_Cond1920_59, n_Proj1922_45, 17, e_pos1_84);
+       ext_grs_edge_t *e_pos0_117_123 = ext_grs_act_add_edge_to_keep(pattern, "pos0_117_123", -1, n_Block2006_61, n_Jmp2084_86, 18, e_pos0_117);
+       ext_grs_edge_t *e_pos1_55_124 = ext_grs_act_add_edge_to_keep(pattern, "pos1_55_124", 0, n_Cond1920_59, n_Proj1921_44, 20, e_pos1_55);
+       ext_grs_edge_t *e_e111_125 = ext_grs_act_add_edge_to_keep(pattern, "e111_125", ext_grs_NO_EDGE_POS, n_Jmp2084_86, n_Block2008_60, 19, e_e111);
+       ext_grs_edge_t *e_e110_126 = ext_grs_act_add_edge_to_keep(pattern, "e110_126", ext_grs_NO_EDGE_POS, n_Jmp5770_56, n_Block2008_60, 21, e_e110);
+       ext_grs_edge_t *e_pos2_59_127 = ext_grs_act_add_edge_to_keep(pattern, "pos2_59_127", 1, n_VProj2128_62, n_Cmp5666_81, 22, e_pos2_59);
+       ext_grs_edge_t *e_pos1_56_128 = ext_grs_act_add_edge_to_keep(pattern, "pos1_56_128", 0, n_VProj1917_71, n_Cmp5664_78, 23, e_pos1_56);
+       ext_grs_edge_t *e_pos2_57_129 = ext_grs_act_add_edge_to_keep(pattern, "pos2_57_129", 1, n_VProj1908_90, n_Cmp5664_78, 24, e_pos2_57);
+       ext_grs_edge_t *e_pos0_97_130 = ext_grs_act_add_edge_to_keep(pattern, "pos0_97_130", -1, n_Block1804_93, n_Cond1920_59, 25, e_pos0_97);
+       ext_grs_edge_t *e_pos1_58_131 = ext_grs_act_add_edge_to_keep(pattern, "pos1_58_131", 0, n_VProj2137_50, n_Cmp5666_81, 26, e_pos1_58);
+       ext_grs_edge_t *e_pos0_99_132 = ext_grs_act_add_edge_to_keep(pattern, "pos0_99_132", -1, n_Block1802_95, n_Jmp1864_92, 27, e_pos0_99);
+       ext_grs_edge_t *e_pos0_94_133 = ext_grs_act_add_edge_to_keep(pattern, "pos0_94_133", -1, n_Block5769_84, n_Jmp5770_56, 29, e_pos0_94);
+       ext_grs_edge_t *e_e118_134 = ext_grs_act_add_edge_to_keep(pattern, "e118_134", ext_grs_NO_EDGE_POS, n_Block1898_83, n_VProj61_43, 30, e_e118);
+       ext_grs_edge_t *e_pos2_125_135 = ext_grs_act_add_edge_to_keep(pattern, "pos2_125_135", 1, n_VProj1814_82, n_Cmp5663_77, 31, e_pos2_125);
+       ext_grs_edge_t *e_pos2_127_136 = ext_grs_act_add_edge_to_keep(pattern, "pos2_127_136", 1, n_VProj2018_75, n_Cmp5665_79, 32, e_pos2_127);
+       ext_grs_edge_t *e_e60_137 = ext_grs_act_add_edge_to_keep(pattern, "e60_137", ext_grs_NO_EDGE_POS, n_Proj1827_94, n_Block5765_88, 33, e_e60);
+       ext_grs_edge_t *e_e65_138 = ext_grs_act_add_edge_to_keep(pattern, "e65_138", ext_grs_NO_EDGE_POS, n_Jmp5768_51, n_Block1898_83, 34, e_e65);
+       ext_grs_edge_t *e_e67_139 = ext_grs_act_add_edge_to_keep(pattern, "e67_139", ext_grs_NO_EDGE_POS, n_Block4800_67, n_VProj55_66, 37, e_e67);
+       ext_grs_edge_t *e_e66_140 = ext_grs_act_add_edge_to_keep(pattern, "e66_140", ext_grs_NO_EDGE_POS, n_Jmp1974_68, n_Block1898_83, 38, e_e66);
+       ext_grs_edge_t *e_e100_141 = ext_grs_act_add_edge_to_keep(pattern, "e100_141", ext_grs_NO_EDGE_POS, n_Block2008_60, n_VProj57_76, 41, e_e100);
+       ext_grs_edge_t *e_pos0_88_142 = ext_grs_act_add_edge_to_keep(pattern, "pos0_88_142", -1, n_Block2117_72, n_Jmp2160_57, 42, e_pos0_88);
+       ext_grs_edge_t *e_pos0_86_143 = ext_grs_act_add_edge_to_keep(pattern, "pos0_86_143", -1, n_Vector_op_Block_85, n_Cond1826_58, 43, e_pos0_86);
+       ext_grs_edge_t *e_e109_144 = ext_grs_act_add_edge_to_keep(pattern, "e109_144", ext_grs_NO_EDGE_POS, n_Proj1828_96, n_Block1802_95, 44, e_e109);
+       ext_grs_edge_t *e_pos0_82_145 = ext_grs_act_add_edge_to_keep(pattern, "pos0_82_145", -1, n_Block5767_89, n_Jmp5768_51, 45, e_pos0_82);
+       ext_grs_edge_t *e_pos1_64_146 = ext_grs_act_add_edge_to_keep(pattern, "pos1_64_146", 0, n_Arg_0_54, n_VProj2018_75, 46, e_pos1_64);
+       ext_grs_edge_t *e_pos1_63_147 = ext_grs_act_add_edge_to_keep(pattern, "pos1_63_147", 0, n_Proj2029_97, n_Cond2030_70, 48, e_pos1_63);
+       ext_grs_edge_t *e_e103_148 = ext_grs_act_add_edge_to_keep(pattern, "e103_148", ext_grs_NO_EDGE_POS, n_Block1804_93, n_VProj59_48, 50, e_e103);
+       ext_grs_edge_t *e_pos1_61_149 = ext_grs_act_add_edge_to_keep(pattern, "pos1_61_149", 0, n_Cond2030_70, n_Proj2032_73, 51, e_pos1_61);
+       ext_grs_edge_t *e_pos1_108_150 = ext_grs_act_add_edge_to_keep(pattern, "pos1_108_150", 0, n_Cmp5664_78, n_Proj1919_49, 52, e_pos1_108);
+       ext_grs_edge_t *e_pos2_131_151 = ext_grs_act_add_edge(pattern, "pos2_131_151", 1, n_Arg_1_55, n_Vector_op, 81);
+       ext_grs_edge_t *e_pos0_74_152 = ext_grs_act_add_edge_to_keep(pattern, "pos0_74_152", -1, n_Block2008_60, n_Cond2140_52, 53, e_pos0_74);
+       ext_grs_edge_t *e_pos0_71_153 = ext_grs_act_add_edge_to_keep(pattern, "pos0_71_153", -1, n_Block5765_88, n_Jmp5766_53, 54, e_pos0_71);
+       ext_grs_edge_t *e_pos0_76_154 = ext_grs_act_add_edge_to_keep(pattern, "pos0_76_154", -1, n_Block1896_80, n_Jmp1974_68, 55, e_pos0_76);
+       ext_grs_edge_t *e_pos1_106_155 = ext_grs_act_add_edge_to_keep(pattern, "pos1_106_155", 0, n_Arg_1_55, n_VProj1823_63, 56, e_pos1_106);
+       ext_grs_edge_t *e_pos1_107_156 = ext_grs_act_add_edge_to_keep(pattern, "pos1_107_156", 0, n_Cond2140_52, n_Proj2141_46, 57, e_pos1_107);
+       ext_grs_edge_t *e_pos0_62_157 = ext_grs_act_add_edge_to_keep(pattern, "pos0_62_157", -1, n_Block1898_83, n_Cond2030_70, 58, e_pos0_62);
+       ext_grs_edge_t *e_pos1_92_158 = ext_grs_act_add_edge_to_keep(pattern, "pos1_92_158", 0, n_Cmp5663_77, n_Proj1825_91, 59, e_pos1_92);
+       ext_grs_edge_t *e_e96_159 = ext_grs_act_add_edge_to_keep(pattern, "e96_159", ext_grs_NO_EDGE_POS, n_Proj2142_47, n_Block5771_69, 60, e_e96);
+       ext_grs_edge_t *e_pos1_95_160 = ext_grs_act_add_edge_to_keep(pattern, "pos1_95_160", 0, n_Cond1826_58, n_Proj1827_94, 61, e_pos1_95);
+       ext_grs_edge_t *e_pos1_98_161 = ext_grs_act_add_edge_to_keep(pattern, "pos1_98_161", 0, n_Proj1919_49, n_Cond1920_59, 63, e_pos1_98);
+       ext_grs_edge_t *e_pos1_126_162 = ext_grs_act_add_edge_to_keep(pattern, "pos1_126_162", 0, n_VProj2027_64, n_Cmp5665_79, 62, e_pos1_126);
+       ext_grs_edge_t *e_e90_163 = ext_grs_act_add_edge_to_keep(pattern, "e90_163", ext_grs_NO_EDGE_POS, n_Jmp5766_53, n_Block1804_93, 64, e_e90);
+       ext_grs_edge_t *e_e93_164 = ext_grs_act_add_edge_to_keep(pattern, "e93_164", ext_grs_NO_EDGE_POS, n_Proj2141_46, n_Block2117_72, 66, e_e93);
+       ext_grs_edge_t *e_pos1_122_165 = ext_grs_act_add_edge_to_keep(pattern, "pos1_122_165", 0, n_Cond2140_52, n_Proj2142_47, 65, e_pos1_122);
+       ext_grs_edge_t *e_pos1_123_166 = ext_grs_act_add_edge_to_keep(pattern, "pos1_123_166", 0, n_Arg_0_54, n_VProj1908_90, 67, e_pos1_123);
+       ext_grs_edge_t *e_e91_167 = ext_grs_act_add_edge_to_keep(pattern, "e91_167", ext_grs_NO_EDGE_POS, n_Jmp1864_92, n_Block1804_93, 69, e_e91);
+       ext_grs_edge_t *e_pos1_124_168 = ext_grs_act_add_edge_to_keep(pattern, "pos1_124_168", 0, n_VProj1823_63, n_Cmp5663_77, 68, e_pos1_124);
+       ext_grs_edge_t *e_pos1_115_169 = ext_grs_act_add_edge_to_keep(pattern, "pos1_115_169", 0, n_Arg_1_55, n_VProj1917_71, 70, e_pos1_115);
+       ext_grs_edge_t *e_pos1_116_170 = ext_grs_act_add_edge_to_keep(pattern, "pos1_116_170", 0, n_Arg_0_54, n_VProj2128_62, 71, e_pos1_116);
+       ext_grs_edge_t *e_pos1_114_171 = ext_grs_act_add_edge_to_keep(pattern, "pos1_114_171", 0, n_Cond1826_58, n_Proj1828_96, 72, e_pos1_114);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_39651);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_39654);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_39657);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_39660);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_39663);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* maxps_variant0 */
+
+
+/* functions for evaluation of conditions of action mulps_4_32_am_variant0 */
+static int grs_cond_func_37166(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[19/* Proj1411 */]) == 0;
+}
+static int grs_cond_func_37169(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[21/* Proj1459 */]) == 0;
+}
+static int grs_cond_func_37172(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[20/* Const1374 */])) == 4;
+}
+static int grs_cond_func_37175(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj1436 */]) == 3;
+}
+static int grs_cond_func_37178(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[8/* Proj1388 */]) == 3;
+}
+static int grs_cond_func_37181(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[1/* VProj1380 */]) == 0;
+}
+static int grs_cond_func_37184(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[12/* VProj1428 */]) == 2;
+}
+static int grs_cond_func_37187(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[22/* MultipleAdd5752 */]) == 2;
+}
+static int grs_cond_func_37190(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[5/* Const1424 */])) == 8;
+}
+static int grs_cond_func_37193(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[2/* Proj1387 */]) == 0;
+}
+static int grs_cond_func_37196(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[11/* Proj1435 */]) == 0;
+}
+static int grs_cond_func_37199(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[16/* MultipleAdd5753 */]) == 2;
+}
+static int grs_cond_func_37202(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Proj1412 */]) == 3;
+}
+static int grs_cond_func_37205(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[3/* Proj1460 */]) == 3;
+}
+static int grs_cond_func_37208(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[29/* VProj1452 */]) == 3;
+}
+static int grs_cond_func_37211(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[14/* MultipleAdd5754 */]) == 2;
+}
+static int grs_cond_func_37214(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[18/* MultipleAdd5755 */]) == 2;
+}
+static int grs_cond_func_37217(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[24/* VProj1404 */]) == 1;
+}
+static int grs_cond_func_37220(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[4/* Const1448 */])) == 12;
+}
+
+static void *grs_eval_out_func_37390(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[31/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_37393(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[30/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_37396(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[32/* VProj30 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_37399(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[33/* VProj32 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_37402(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[34/* VProj34 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_37405(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[36/* VProj36 */], 1);
+  return(NULL);
+}
+/* functions for building the pattern of action mulps_4_32_am_variant0 */
+static _inline ext_grs_action_t *grs_action_mulps_4_32_am_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "mulps_4_32_am_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Load1458 = ext_grs_act_add_node(pattern, "Load1458", grs_op_Load, mode_T, 0);
+    ext_grs_node_t *n_VProj1380 = ext_grs_act_add_node(pattern, "VProj1380", grs_op_VProj, mode_F, 1);
+    ext_grs_node_t *n_Proj1387 = ext_grs_act_add_node(pattern, "Proj1387", grs_op_Proj, mode_M, 2);
+    ext_grs_node_t *n_Proj1460 = ext_grs_act_add_node(pattern, "Proj1460", grs_op_Proj, mode_F, 3);
+    ext_grs_node_t *n_Const1448 = ext_grs_act_add_node(pattern, "Const1448", grs_op_Const, mode_Is, 4);
+    ext_grs_node_t *n_Const1424 = ext_grs_act_add_node(pattern, "Const1424", grs_op_Const, mode_Is, 5);
+    ext_grs_node_t *n_Load1434 = ext_grs_act_add_node(pattern, "Load1434", grs_op_Load, mode_T, 6);
+    ext_grs_node_t *n_Load1410 = ext_grs_act_add_node(pattern, "Load1410", grs_op_Load, mode_T, 7);
+    ext_grs_node_t *n_Proj1388 = ext_grs_act_add_node(pattern, "Proj1388", grs_op_Proj, mode_F, 8);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 9);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 10);
+    ext_grs_node_t *n_Proj1435 = ext_grs_act_add_node(pattern, "Proj1435", grs_op_Proj, mode_M, 11);
+    ext_grs_node_t *n_VProj1428 = ext_grs_act_add_node(pattern, "VProj1428", grs_op_VProj, mode_F, 12);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 13);
+    ext_grs_node_t *n_MultipleAdd5754 = ext_grs_act_add_node(pattern, "MultipleAdd5754", grs_op_MultipleAdd, mode_P, 14);
+    ext_grs_node_t *n_Proj1412 = ext_grs_act_add_node(pattern, "Proj1412", grs_op_Proj, mode_F, 15);
+    ext_grs_node_t *n_MultipleAdd5753 = ext_grs_act_add_node(pattern, "MultipleAdd5753", grs_op_MultipleAdd, mode_P, 16);
+    ext_grs_node_t *n_Proj1436 = ext_grs_act_add_node(pattern, "Proj1436", grs_op_Proj, mode_F, 17);
+    ext_grs_node_t *n_MultipleAdd5755 = ext_grs_act_add_node(pattern, "MultipleAdd5755", grs_op_MultipleAdd, mode_P, 18);
+    ext_grs_node_t *n_Proj1411 = ext_grs_act_add_node(pattern, "Proj1411", grs_op_Proj, mode_M, 19);
+    ext_grs_node_t *n_Const1374 = ext_grs_act_add_node(pattern, "Const1374", grs_op_Const, mode_Is, 20);
+    ext_grs_node_t *n_Proj1459 = ext_grs_act_add_node(pattern, "Proj1459", grs_op_Proj, mode_M, 21);
+    ext_grs_node_t *n_MultipleAdd5752 = ext_grs_act_add_node(pattern, "MultipleAdd5752", grs_op_MultipleAdd, mode_P, 22);
+    ext_grs_node_t *n_Vector_Result0_Mul1389 = ext_grs_act_add_node(pattern, "Vector_Result0_Mul1389", grs_op_Mul, mode_F, 23);
+    ext_grs_node_t *n_VProj1404 = ext_grs_act_add_node(pattern, "VProj1404", grs_op_VProj, mode_F, 24);
+    ext_grs_node_t *n_Load1386 = ext_grs_act_add_node(pattern, "Load1386", grs_op_Load, mode_T, 25);
+    ext_grs_node_t *n_Vector_Result3_Mul1461 = ext_grs_act_add_node(pattern, "Vector_Result3_Mul1461", grs_op_Mul, mode_F, 26);
+    ext_grs_node_t *n_Vector_Result2_Mul1437 = ext_grs_act_add_node(pattern, "Vector_Result2_Mul1437", grs_op_Mul, mode_F, 27);
+    ext_grs_node_t *n_Vector_Result1_Mul1413 = ext_grs_act_add_node(pattern, "Vector_Result1_Mul1413", grs_op_Mul, mode_F, 28);
+    ext_grs_node_t *n_VProj1452 = ext_grs_act_add_node(pattern, "VProj1452", grs_op_VProj, mode_F, 29);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_30 = ext_grs_act_add_edge(pattern, "pos1_30", 0, n_Load1410, n_Proj1411, 0);
+    ext_grs_edge_t *e_pos1_31 = ext_grs_act_add_edge(pattern, "pos1_31", 0, n_Load1458, n_Proj1459, 1);
+    ext_grs_edge_t *e_e36 = ext_grs_act_add_edge(pattern, "e36", ext_grs_NO_EDGE_POS, n_Proj1388, n_Vector_Result0_Mul1389, 2);
+    ext_grs_edge_t *e_pos0_35 = ext_grs_act_add_edge(pattern, "pos0_35", -1, n_Vector_op_Block, n_Vector_Result0_Mul1389, 3);
+    ext_grs_edge_t *e_pos1_39 = ext_grs_act_add_edge(pattern, "pos1_39", 0, n_Arg_0, n_VProj1380, 4);
+    ext_grs_edge_t *e_pos1_32 = ext_grs_act_add_edge(pattern, "pos1_32", 0, n_Load1434, n_Proj1436, 5);
+    ext_grs_edge_t *e_pos1_33 = ext_grs_act_add_edge(pattern, "pos1_33", 0, n_Load1386, n_Proj1388, 6);
+    ext_grs_edge_t *e_pos2_34 = ext_grs_act_add_edge(pattern, "pos2_34", 1, n_MultipleAdd5752, n_Load1386, 7);
+    ext_grs_edge_t *e_pos2_38 = ext_grs_act_add_edge(pattern, "pos2_38", 1, n_MultipleAdd5754, n_Load1434, 8);
+    ext_grs_edge_t *e_e37 = ext_grs_act_add_edge(pattern, "e37", ext_grs_NO_EDGE_POS, n_VProj1380, n_Vector_Result0_Mul1389, 9);
+    ext_grs_edge_t *e_e46 = ext_grs_act_add_edge(pattern, "e46", ext_grs_NO_EDGE_POS, n_VProj1452, n_Vector_Result3_Mul1461, 10);
+    ext_grs_edge_t *e_pos1_40 = ext_grs_act_add_edge(pattern, "pos1_40", 0, n_Arg_0, n_VProj1428, 11);
+    ext_grs_edge_t *e_e47 = ext_grs_act_add_edge(pattern, "e47", ext_grs_NO_EDGE_POS, n_Const1374, n_MultipleAdd5753, 12);
+    ext_grs_edge_t *e_pos1_42 = ext_grs_act_add_edge(pattern, "pos1_42", 0, n_Load1386, n_Proj1387, 13);
+    ext_grs_edge_t *e_e45 = ext_grs_act_add_edge(pattern, "e45", ext_grs_NO_EDGE_POS, n_Proj1460, n_Vector_Result3_Mul1461, 14);
+    ext_grs_edge_t *e_pos0_61 = ext_grs_act_add_edge(pattern, "pos0_61", -1, n_Vector_op_Block, n_Vector_Result1_Mul1413, 15);
+    ext_grs_edge_t *e_e41 = ext_grs_act_add_edge(pattern, "e41", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5752, 16);
+    ext_grs_edge_t *e_pos1_43 = ext_grs_act_add_edge(pattern, "pos1_43", 0, n_Load1434, n_Proj1435, 17);
+    ext_grs_edge_t *e_e48 = ext_grs_act_add_edge(pattern, "e48", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5753, 18);
+    ext_grs_edge_t *e_e50 = ext_grs_act_add_edge(pattern, "e50", ext_grs_NO_EDGE_POS, n_Proj1436, n_Vector_Result2_Mul1437, 19);
+    ext_grs_edge_t *e_e51 = ext_grs_act_add_edge(pattern, "e51", ext_grs_NO_EDGE_POS, n_VProj1428, n_Vector_Result2_Mul1437, 20);
+    ext_grs_edge_t *e_e56 = ext_grs_act_add_edge(pattern, "e56", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5754, 21);
+    ext_grs_edge_t *e_e55 = ext_grs_act_add_edge(pattern, "e55", ext_grs_NO_EDGE_POS, n_Const1424, n_MultipleAdd5754, 22);
+    ext_grs_edge_t *e_e59 = ext_grs_act_add_edge(pattern, "e59", ext_grs_NO_EDGE_POS, n_Const1448, n_MultipleAdd5755, 23);
+    ext_grs_edge_t *e_pos1_54 = ext_grs_act_add_edge(pattern, "pos1_54", 0, n_Arg_0, n_VProj1452, 24);
+    ext_grs_edge_t *e_pos2_57 = ext_grs_act_add_edge(pattern, "pos2_57", 1, n_MultipleAdd5753, n_Load1410, 25);
+    ext_grs_edge_t *e_pos2_58 = ext_grs_act_add_edge(pattern, "pos2_58", 1, n_MultipleAdd5755, n_Load1458, 26);
+    ext_grs_edge_t *e_pos1_53 = ext_grs_act_add_edge(pattern, "pos1_53", 0, n_Load1458, n_Proj1460, 27);
+    ext_grs_edge_t *e_pos1_52 = ext_grs_act_add_edge(pattern, "pos1_52", 0, n_Load1410, n_Proj1412, 28);
+    ext_grs_edge_t *e_e60 = ext_grs_act_add_edge(pattern, "e60", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5755, 29);
+    ext_grs_edge_t *e_e63 = ext_grs_act_add_edge(pattern, "e63", ext_grs_NO_EDGE_POS, n_VProj1404, n_Vector_Result1_Mul1413, 30);
+    ext_grs_edge_t *e_e62 = ext_grs_act_add_edge(pattern, "e62", ext_grs_NO_EDGE_POS, n_Proj1412, n_Vector_Result1_Mul1413, 31);
+    ext_grs_edge_t *e_pos0_49 = ext_grs_act_add_edge(pattern, "pos0_49", -1, n_Vector_op_Block, n_Vector_Result2_Mul1437, 32);
+    ext_grs_edge_t *e_pos0_44 = ext_grs_act_add_edge(pattern, "pos0_44", -1, n_Vector_op_Block, n_Vector_Result3_Mul1461, 33);
+    ext_grs_edge_t *e_pos1_64 = ext_grs_act_add_edge(pattern, "pos1_64", 0, n_Arg_0, n_VProj1404, 34);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1411};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37166, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1459};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37169, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1374};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37172, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1436};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37175, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1388};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37178, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1380};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37181, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1428};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37184, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5752};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37187, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1424};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37190, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1387};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37193, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1435};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37196, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5753};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37199, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1412};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37202, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1460};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37205, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1452};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37208, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5754};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37211, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5755};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37214, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1404};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37217, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1448};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37220, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Load1458_172 = ext_grs_act_add_node_to_keep(pattern, "Load1458_172", grs_op_Load, mode_T, 0, n_Load1458);
+       ext_grs_node_t *n_VProj1380_173 = ext_grs_act_add_node_to_keep(pattern, "VProj1380_173", grs_op_VProj, mode_F, 1, n_VProj1380);
+       ext_grs_node_t *n_Proj1387_174 = ext_grs_act_add_node_to_keep(pattern, "Proj1387_174", grs_op_Proj, mode_M, 2, n_Proj1387);
+       ext_grs_node_t *n_Proj1460_175 = ext_grs_act_add_node_to_keep(pattern, "Proj1460_175", grs_op_Proj, mode_F, 3, n_Proj1460);
+       ext_grs_node_t *n_Const1448_176 = ext_grs_act_add_node_to_keep(pattern, "Const1448_176", grs_op_Const, mode_Is, 4, n_Const1448);
+       ext_grs_node_t *n_Const1424_177 = ext_grs_act_add_node_to_keep(pattern, "Const1424_177", grs_op_Const, mode_Is, 5, n_Const1424);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 30);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 31);
+       ext_grs_node_t *n_Load1434_178 = ext_grs_act_add_node_to_keep(pattern, "Load1434_178", grs_op_Load, mode_T, 6, n_Load1434);
+       ext_grs_node_t *n_Load1410_179 = ext_grs_act_add_node_to_keep(pattern, "Load1410_179", grs_op_Load, mode_T, 7, n_Load1410);
+       ext_grs_node_t *n_Proj1388_180 = ext_grs_act_add_node_to_keep(pattern, "Proj1388_180", grs_op_Proj, mode_F, 8, n_Proj1388);
+       ext_grs_node_t *n_Arg_0_181 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_181", grs_op_VectorBase, mode_ANY, 9, n_Arg_0);
+       ext_grs_node_t *n_Proj1435_182 = ext_grs_act_add_node_to_keep(pattern, "Proj1435_182", grs_op_Proj, mode_M, 11, n_Proj1435);
+       ext_grs_node_t *n_Arg_1_183 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_183", grs_op_VectorBase, mode_ANY, 10, n_Arg_1);
+       ext_grs_node_t *n_VProj1428_184 = ext_grs_act_add_node_to_keep(pattern, "VProj1428_184", grs_op_VProj, mode_F, 12, n_VProj1428);
+       ext_grs_node_t *n_Vector_op_Block_185 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_185", grs_op_Block, mode_BB, 13, n_Vector_op_Block);
+       ext_grs_node_t *n_Proj1412_186 = ext_grs_act_add_node_to_keep(pattern, "Proj1412_186", grs_op_Proj, mode_F, 15, n_Proj1412);
+       ext_grs_node_t *n_MultipleAdd5754_187 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5754_187", grs_op_MultipleAdd, mode_P, 14, n_MultipleAdd5754);
+       ext_grs_node_t *n_MultipleAdd5753_188 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5753_188", grs_op_MultipleAdd, mode_P, 16, n_MultipleAdd5753);
+       ext_grs_node_t *n_Proj1436_189 = ext_grs_act_add_node_to_keep(pattern, "Proj1436_189", grs_op_Proj, mode_F, 17, n_Proj1436);
+       ext_grs_node_t *n_Proj1411_190 = ext_grs_act_add_node_to_keep(pattern, "Proj1411_190", grs_op_Proj, mode_M, 19, n_Proj1411);
+       ext_grs_node_t *n_MultipleAdd5755_191 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5755_191", grs_op_MultipleAdd, mode_P, 18, n_MultipleAdd5755);
+       ext_grs_node_t *n_Const1374_192 = ext_grs_act_add_node_to_keep(pattern, "Const1374_192", grs_op_Const, mode_Is, 20, n_Const1374);
+       ext_grs_node_t *n_Proj1459_193 = ext_grs_act_add_node_to_keep(pattern, "Proj1459_193", grs_op_Proj, mode_M, 21, n_Proj1459);
+       ext_grs_node_t *n_MultipleAdd5752_194 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5752_194", grs_op_MultipleAdd, mode_P, 22, n_MultipleAdd5752);
+       ext_grs_node_t *n_VProj30_195 = ext_grs_act_add_node_to_keep(pattern, "VProj30_195", grs_op_VProj, mode_F, 32, n_Vector_Result0_Mul1389);
+       ext_grs_node_t *n_Load1386_196 = ext_grs_act_add_node_to_keep(pattern, "Load1386_196", grs_op_Load, mode_T, 25, n_Load1386);
+       ext_grs_node_t *n_VProj1404_197 = ext_grs_act_add_node_to_keep(pattern, "VProj1404_197", grs_op_VProj, mode_F, 24, n_VProj1404);
+       ext_grs_node_t *n_VProj32_198 = ext_grs_act_add_node_to_keep(pattern, "VProj32_198", grs_op_VProj, mode_F, 33, n_Vector_Result3_Mul1461);
+       ext_grs_node_t *n_VProj34_199 = ext_grs_act_add_node_to_keep(pattern, "VProj34_199", grs_op_VProj, mode_F, 34, n_Vector_Result2_Mul1437);
+       ext_grs_node_t *n_Bad30 = ext_grs_act_add_node(pattern, "Bad30", grs_op_Bad, mode_ANY, 35);
+       ext_grs_node_t *n_VProj36_200 = ext_grs_act_add_node_to_keep(pattern, "VProj36_200", grs_op_VProj, mode_F, 36, n_Vector_Result1_Mul1413);
+       ext_grs_node_t *n_VProj1452_201 = ext_grs_act_add_node_to_keep(pattern, "VProj1452_201", grs_op_VProj, mode_F, 29, n_VProj1452);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 37);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_30_202 = ext_grs_act_add_edge_to_keep(pattern, "pos1_30_202", 0, n_Load1410_179, n_Proj1411_190, 0, e_pos1_30);
+       ext_grs_edge_t *e_pos1_31_203 = ext_grs_act_add_edge_to_keep(pattern, "pos1_31_203", 0, n_Load1458_172, n_Proj1459_193, 1, e_pos1_31);
+       ext_grs_edge_t *e_pos0_35_204 = ext_grs_act_add_edge_to_keep(pattern, "pos0_35_204", -1, n_Vector_op_Block_185, n_VProj30_195, 3, e_pos0_35);
+       ext_grs_edge_t *e_pos0_72_205 = ext_grs_act_add_edge(pattern, "pos0_72_205", -1, n_Vector_op_Block_185, n_Vector_op_ProjM, 35);
+       ext_grs_edge_t *e_pos1_39_206 = ext_grs_act_add_edge_to_keep(pattern, "pos1_39_206", 0, n_Arg_0_181, n_VProj1380_173, 4, e_pos1_39);
+       ext_grs_edge_t *e_pos1_32_207 = ext_grs_act_add_edge_to_keep(pattern, "pos1_32_207", 0, n_Load1434_178, n_Proj1436_189, 5, e_pos1_32);
+       ext_grs_edge_t *e_pos1_33_208 = ext_grs_act_add_edge_to_keep(pattern, "pos1_33_208", 0, n_Load1386_196, n_Proj1388_180, 6, e_pos1_33);
+       ext_grs_edge_t *e_pos2_34_209 = ext_grs_act_add_edge_to_keep(pattern, "pos2_34_209", 1, n_MultipleAdd5752_194, n_Load1386_196, 7, e_pos2_34);
+       ext_grs_edge_t *e_pos1_76_210 = ext_grs_act_add_edge(pattern, "pos1_76_210", 0, n_Vector_op_ProjData, n_VProj36_200, 36);
+       ext_grs_edge_t *e_pos2_38_211 = ext_grs_act_add_edge_to_keep(pattern, "pos2_38_211", 1, n_MultipleAdd5754_187, n_Load1434_178, 8, e_pos2_38);
+       ext_grs_edge_t *e_pos1_73_212 = ext_grs_act_add_edge(pattern, "pos1_73_212", 0, n_Vector_op_ProjData, n_VProj30_195, 37);
+       ext_grs_edge_t *e_pos1_75_213 = ext_grs_act_add_edge(pattern, "pos1_75_213", 0, n_Vector_op_ProjData, n_VProj34_199, 38);
+       ext_grs_edge_t *e_pos1_74_214 = ext_grs_act_add_edge(pattern, "pos1_74_214", 0, n_Vector_op_ProjData, n_VProj32_198, 39);
+       ext_grs_edge_t *e_pos1_71_215 = ext_grs_act_add_edge(pattern, "pos1_71_215", 0, n_Vector_op, n_Vector_op_ProjM, 40);
+       ext_grs_edge_t *e_pos1_40_216 = ext_grs_act_add_edge_to_keep(pattern, "pos1_40_216", 0, n_Arg_0_181, n_VProj1428_184, 11, e_pos1_40);
+       ext_grs_edge_t *e_e47_217 = ext_grs_act_add_edge_to_keep(pattern, "e47_217", ext_grs_NO_EDGE_POS, n_Const1374_192, n_MultipleAdd5753_188, 12, e_e47);
+       ext_grs_edge_t *e_pos1_42_218 = ext_grs_act_add_edge_to_keep(pattern, "pos1_42_218", 0, n_Load1386_196, n_Proj1387_174, 13, e_pos1_42);
+       ext_grs_edge_t *e_pos3_70_219 = ext_grs_act_add_edge(pattern, "pos3_70_219", 2, n_Bad30, n_Vector_op, 41);
+       ext_grs_edge_t *e_pos0_61_220 = ext_grs_act_add_edge_to_keep(pattern, "pos0_61_220", -1, n_Vector_op_Block_185, n_VProj36_200, 15, e_pos0_61);
+       ext_grs_edge_t *e_e41_221 = ext_grs_act_add_edge_to_keep(pattern, "e41_221", ext_grs_NO_EDGE_POS, n_Arg_1_183, n_MultipleAdd5752_194, 16, e_e41);
+       ext_grs_edge_t *e_pos0_65_222 = ext_grs_act_add_edge(pattern, "pos0_65_222", -1, n_Vector_op_Block_185, n_Vector_op, 42);
+       ext_grs_edge_t *e_pos0_66_223 = ext_grs_act_add_edge(pattern, "pos0_66_223", -1, n_Vector_op_Block_185, n_Vector_op_ProjData, 43);
+       ext_grs_edge_t *e_pos1_43_224 = ext_grs_act_add_edge_to_keep(pattern, "pos1_43_224", 0, n_Load1434_178, n_Proj1435_182, 17, e_pos1_43);
+       ext_grs_edge_t *e_pos2_68_225 = ext_grs_act_add_edge(pattern, "pos2_68_225", 1, n_MultipleAdd5752_194, n_Vector_op, 44);
+       ext_grs_edge_t *e_e48_226 = ext_grs_act_add_edge_to_keep(pattern, "e48_226", ext_grs_NO_EDGE_POS, n_Arg_1_183, n_MultipleAdd5753_188, 18, e_e48);
+       ext_grs_edge_t *e_e56_227 = ext_grs_act_add_edge_to_keep(pattern, "e56_227", ext_grs_NO_EDGE_POS, n_Arg_1_183, n_MultipleAdd5754_187, 21, e_e56);
+       ext_grs_edge_t *e_e55_228 = ext_grs_act_add_edge_to_keep(pattern, "e55_228", ext_grs_NO_EDGE_POS, n_Const1424_177, n_MultipleAdd5754_187, 22, e_e55);
+       ext_grs_edge_t *e_e59_229 = ext_grs_act_add_edge_to_keep(pattern, "e59_229", ext_grs_NO_EDGE_POS, n_Const1448_176, n_MultipleAdd5755_191, 23, e_e59);
+       ext_grs_edge_t *e_pos1_54_230 = ext_grs_act_add_edge_to_keep(pattern, "pos1_54_230", 0, n_Arg_0_181, n_VProj1452_201, 24, e_pos1_54);
+       ext_grs_edge_t *e_pos2_57_231 = ext_grs_act_add_edge_to_keep(pattern, "pos2_57_231", 1, n_MultipleAdd5753_188, n_Load1410_179, 25, e_pos2_57);
+       ext_grs_edge_t *e_pos2_58_232 = ext_grs_act_add_edge_to_keep(pattern, "pos2_58_232", 1, n_MultipleAdd5755_191, n_Load1458_172, 26, e_pos2_58);
+       ext_grs_edge_t *e_pos1_53_233 = ext_grs_act_add_edge_to_keep(pattern, "pos1_53_233", 0, n_Load1458_172, n_Proj1460_175, 27, e_pos1_53);
+       ext_grs_edge_t *e_pos1_52_234 = ext_grs_act_add_edge_to_keep(pattern, "pos1_52_234", 0, n_Load1410_179, n_Proj1412_186, 28, e_pos1_52);
+       ext_grs_edge_t *e_e60_235 = ext_grs_act_add_edge_to_keep(pattern, "e60_235", ext_grs_NO_EDGE_POS, n_Arg_1_183, n_MultipleAdd5755_191, 29, e_e60);
+       ext_grs_edge_t *e_pos0_49_236 = ext_grs_act_add_edge_to_keep(pattern, "pos0_49_236", -1, n_Vector_op_Block_185, n_VProj34_199, 32, e_pos0_49);
+       ext_grs_edge_t *e_pos0_44_237 = ext_grs_act_add_edge_to_keep(pattern, "pos0_44_237", -1, n_Vector_op_Block_185, n_VProj32_198, 33, e_pos0_44);
+       ext_grs_edge_t *e_pos1_67_238 = ext_grs_act_add_edge(pattern, "pos1_67_238", 0, n_Vector_op, n_Vector_op_ProjData, 45);
+       ext_grs_edge_t *e_pos1_69_239 = ext_grs_act_add_edge(pattern, "pos1_69_239", 0, n_Arg_0_181, n_Vector_op, 46);
+       ext_grs_edge_t *e_pos1_64_240 = ext_grs_act_add_edge_to_keep(pattern, "pos1_64_240", 0, n_Arg_0_181, n_VProj1404_197, 34, e_pos1_64);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37390);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37393);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37396);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37399);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37402);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37405);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* mulps_4_32_am_variant0 */
+
+
+/* functions for evaluation of conditions of action mulps_4_32_am_variant1 */
+static int grs_cond_func_37731(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[19/* Proj1411 */]) == 0;
+}
+static int grs_cond_func_37734(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[21/* Proj1459 */]) == 0;
+}
+static int grs_cond_func_37737(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[20/* Const1374 */])) == 4;
+}
+static int grs_cond_func_37740(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj1436 */]) == 3;
+}
+static int grs_cond_func_37743(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[8/* Proj1388 */]) == 3;
+}
+static int grs_cond_func_37746(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[1/* VProj1380 */]) == 0;
+}
+static int grs_cond_func_37749(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[12/* VProj1428 */]) == 2;
+}
+static int grs_cond_func_37752(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[22/* MultipleAdd5752 */]) == 3;
+}
+static int grs_cond_func_37755(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[5/* Const1424 */])) == 8;
+}
+static int grs_cond_func_37758(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[2/* Proj1387 */]) == 0;
+}
+static int grs_cond_func_37761(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[11/* Proj1435 */]) == 0;
+}
+static int grs_cond_func_37764(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[16/* MultipleAdd5753 */]) == 3;
+}
+static int grs_cond_func_37767(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Proj1412 */]) == 3;
+}
+static int grs_cond_func_37770(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[3/* Proj1460 */]) == 3;
+}
+static int grs_cond_func_37773(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[30/* VProj1452 */]) == 3;
+}
+static int grs_cond_func_37776(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[14/* MultipleAdd5754 */]) == 3;
+}
+static int grs_cond_func_37779(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[18/* MultipleAdd5755 */]) == 3;
+}
+static int grs_cond_func_37782(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[24/* VProj1404 */]) == 1;
+}
+static int grs_cond_func_37785(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[4/* Const1448 */])) == 12;
+}
+
+static void *grs_eval_out_func_37961(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[32/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_37964(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[31/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_37967(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[33/* VProj31 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_37970(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[34/* VProj33 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_37973(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[35/* VProj35 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_37976(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[37/* VProj37 */], 1);
+  return(NULL);
+}
+/* functions for building the pattern of action mulps_4_32_am_variant1 */
+static _inline ext_grs_action_t *grs_action_mulps_4_32_am_variant1_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "mulps_4_32_am_variant1");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Load1458 = ext_grs_act_add_node(pattern, "Load1458", grs_op_Load, mode_T, 0);
+    ext_grs_node_t *n_VProj1380 = ext_grs_act_add_node(pattern, "VProj1380", grs_op_VProj, mode_F, 1);
+    ext_grs_node_t *n_Proj1387 = ext_grs_act_add_node(pattern, "Proj1387", grs_op_Proj, mode_M, 2);
+    ext_grs_node_t *n_Proj1460 = ext_grs_act_add_node(pattern, "Proj1460", grs_op_Proj, mode_F, 3);
+    ext_grs_node_t *n_Const1448 = ext_grs_act_add_node(pattern, "Const1448", grs_op_Const, mode_Is, 4);
+    ext_grs_node_t *n_Const1424 = ext_grs_act_add_node(pattern, "Const1424", grs_op_Const, mode_Is, 5);
+    ext_grs_node_t *n_Load1434 = ext_grs_act_add_node(pattern, "Load1434", grs_op_Load, mode_T, 6);
+    ext_grs_node_t *n_Load1410 = ext_grs_act_add_node(pattern, "Load1410", grs_op_Load, mode_T, 7);
+    ext_grs_node_t *n_Proj1388 = ext_grs_act_add_node(pattern, "Proj1388", grs_op_Proj, mode_F, 8);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 9);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 10);
+    ext_grs_node_t *n_Proj1435 = ext_grs_act_add_node(pattern, "Proj1435", grs_op_Proj, mode_M, 11);
+    ext_grs_node_t *n_VProj1428 = ext_grs_act_add_node(pattern, "VProj1428", grs_op_VProj, mode_F, 12);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 13);
+    ext_grs_node_t *n_MultipleAdd5754 = ext_grs_act_add_node(pattern, "MultipleAdd5754", grs_op_MultipleAdd, mode_P, 14);
+    ext_grs_node_t *n_Proj1412 = ext_grs_act_add_node(pattern, "Proj1412", grs_op_Proj, mode_F, 15);
+    ext_grs_node_t *n_MultipleAdd5753 = ext_grs_act_add_node(pattern, "MultipleAdd5753", grs_op_MultipleAdd, mode_P, 16);
+    ext_grs_node_t *n_Proj1436 = ext_grs_act_add_node(pattern, "Proj1436", grs_op_Proj, mode_F, 17);
+    ext_grs_node_t *n_MultipleAdd5755 = ext_grs_act_add_node(pattern, "MultipleAdd5755", grs_op_MultipleAdd, mode_P, 18);
+    ext_grs_node_t *n_Proj1411 = ext_grs_act_add_node(pattern, "Proj1411", grs_op_Proj, mode_M, 19);
+    ext_grs_node_t *n_Const1374 = ext_grs_act_add_node(pattern, "Const1374", grs_op_Const, mode_Is, 20);
+    ext_grs_node_t *n_Proj1459 = ext_grs_act_add_node(pattern, "Proj1459", grs_op_Proj, mode_M, 21);
+    ext_grs_node_t *n_MultipleAdd5752 = ext_grs_act_add_node(pattern, "MultipleAdd5752", grs_op_MultipleAdd, mode_P, 22);
+    ext_grs_node_t *n_Vector_Result0_Mul1389 = ext_grs_act_add_node(pattern, "Vector_Result0_Mul1389", grs_op_Mul, mode_F, 23);
+    ext_grs_node_t *n_VProj1404 = ext_grs_act_add_node(pattern, "VProj1404", grs_op_VProj, mode_F, 24);
+    ext_grs_node_t *n_Load1386 = ext_grs_act_add_node(pattern, "Load1386", grs_op_Load, mode_T, 25);
+    ext_grs_node_t *n_Vector_Result3_Mul1461 = ext_grs_act_add_node(pattern, "Vector_Result3_Mul1461", grs_op_Mul, mode_F, 26);
+    ext_grs_node_t *n_IR_node5756 = ext_grs_act_add_node(pattern, "IR_node5756", grs_op_IR_node, mode_ANY, 27);
+    ext_grs_node_t *n_Vector_Result2_Mul1437 = ext_grs_act_add_node(pattern, "Vector_Result2_Mul1437", grs_op_Mul, mode_F, 28);
+    ext_grs_node_t *n_Vector_Result1_Mul1413 = ext_grs_act_add_node(pattern, "Vector_Result1_Mul1413", grs_op_Mul, mode_F, 29);
+    ext_grs_node_t *n_VProj1452 = ext_grs_act_add_node(pattern, "VProj1452", grs_op_VProj, mode_F, 30);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_31 = ext_grs_act_add_edge(pattern, "pos1_31", 0, n_Load1410, n_Proj1411, 0);
+    ext_grs_edge_t *e_pos0_36 = ext_grs_act_add_edge(pattern, "pos0_36", -1, n_Vector_op_Block, n_Vector_Result0_Mul1389, 1);
+    ext_grs_edge_t *e_pos1_34 = ext_grs_act_add_edge(pattern, "pos1_34", 0, n_Load1386, n_Proj1388, 2);
+    ext_grs_edge_t *e_pos1_32 = ext_grs_act_add_edge(pattern, "pos1_32", 0, n_Load1458, n_Proj1459, 3);
+    ext_grs_edge_t *e_pos1_33 = ext_grs_act_add_edge(pattern, "pos1_33", 0, n_Load1434, n_Proj1436, 4);
+    ext_grs_edge_t *e_pos2_35 = ext_grs_act_add_edge(pattern, "pos2_35", 1, n_MultipleAdd5752, n_Load1386, 5);
+    ext_grs_edge_t *e_pos2_39 = ext_grs_act_add_edge(pattern, "pos2_39", 1, n_MultipleAdd5754, n_Load1434, 6);
+    ext_grs_edge_t *e_e38 = ext_grs_act_add_edge(pattern, "e38", ext_grs_NO_EDGE_POS, n_VProj1380, n_Vector_Result0_Mul1389, 7);
+    ext_grs_edge_t *e_e37 = ext_grs_act_add_edge(pattern, "e37", ext_grs_NO_EDGE_POS, n_Proj1388, n_Vector_Result0_Mul1389, 8);
+    ext_grs_edge_t *e_pos1_40 = ext_grs_act_add_edge(pattern, "pos1_40", 0, n_Arg_0, n_VProj1380, 9);
+    ext_grs_edge_t *e_e47 = ext_grs_act_add_edge(pattern, "e47", ext_grs_NO_EDGE_POS, n_Proj1460, n_Vector_Result3_Mul1461, 10);
+    ext_grs_edge_t *e_pos1_41 = ext_grs_act_add_edge(pattern, "pos1_41", 0, n_Arg_0, n_VProj1428, 11);
+    ext_grs_edge_t *e_e42 = ext_grs_act_add_edge(pattern, "e42", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5752, 12);
+    ext_grs_edge_t *e_e43 = ext_grs_act_add_edge(pattern, "e43", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5752, 13);
+    ext_grs_edge_t *e_pos0_66 = ext_grs_act_add_edge(pattern, "pos0_66", -1, n_Vector_op_Block, n_Vector_Result1_Mul1413, 14);
+    ext_grs_edge_t *e_pos1_44 = ext_grs_act_add_edge(pattern, "pos1_44", 0, n_Load1386, n_Proj1387, 15);
+    ext_grs_edge_t *e_pos1_45 = ext_grs_act_add_edge(pattern, "pos1_45", 0, n_Load1434, n_Proj1435, 16);
+    ext_grs_edge_t *e_pos2_61 = ext_grs_act_add_edge(pattern, "pos2_61", 1, n_MultipleAdd5753, n_Load1410, 17);
+    ext_grs_edge_t *e_pos2_62 = ext_grs_act_add_edge(pattern, "pos2_62", 1, n_MultipleAdd5755, n_Load1458, 18);
+    ext_grs_edge_t *e_e49 = ext_grs_act_add_edge(pattern, "e49", ext_grs_NO_EDGE_POS, n_Const1374, n_MultipleAdd5753, 19);
+    ext_grs_edge_t *e_e48 = ext_grs_act_add_edge(pattern, "e48", ext_grs_NO_EDGE_POS, n_VProj1452, n_Vector_Result3_Mul1461, 20);
+    ext_grs_edge_t *e_pos0_52 = ext_grs_act_add_edge(pattern, "pos0_52", -1, n_Vector_op_Block, n_Vector_Result2_Mul1437, 21);
+    ext_grs_edge_t *e_e50 = ext_grs_act_add_edge(pattern, "e50", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5753, 22);
+    ext_grs_edge_t *e_e51 = ext_grs_act_add_edge(pattern, "e51", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5753, 23);
+    ext_grs_edge_t *e_e54 = ext_grs_act_add_edge(pattern, "e54", ext_grs_NO_EDGE_POS, n_VProj1428, n_Vector_Result2_Mul1437, 24);
+    ext_grs_edge_t *e_e53 = ext_grs_act_add_edge(pattern, "e53", ext_grs_NO_EDGE_POS, n_Proj1436, n_Vector_Result2_Mul1437, 25);
+    ext_grs_edge_t *e_e58 = ext_grs_act_add_edge(pattern, "e58", ext_grs_NO_EDGE_POS, n_Const1424, n_MultipleAdd5754, 26);
+    ext_grs_edge_t *e_e59 = ext_grs_act_add_edge(pattern, "e59", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5754, 27);
+    ext_grs_edge_t *e_pos1_55 = ext_grs_act_add_edge(pattern, "pos1_55", 0, n_Load1410, n_Proj1412, 28);
+    ext_grs_edge_t *e_pos1_57 = ext_grs_act_add_edge(pattern, "pos1_57", 0, n_Arg_0, n_VProj1452, 29);
+    ext_grs_edge_t *e_pos1_56 = ext_grs_act_add_edge(pattern, "pos1_56", 0, n_Load1458, n_Proj1460, 30);
+    ext_grs_edge_t *e_e60 = ext_grs_act_add_edge(pattern, "e60", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5754, 31);
+    ext_grs_edge_t *e_e65 = ext_grs_act_add_edge(pattern, "e65", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5755, 32);
+    ext_grs_edge_t *e_pos0_46 = ext_grs_act_add_edge(pattern, "pos0_46", -1, n_Vector_op_Block, n_Vector_Result3_Mul1461, 33);
+    ext_grs_edge_t *e_e64 = ext_grs_act_add_edge(pattern, "e64", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5755, 34);
+    ext_grs_edge_t *e_e63 = ext_grs_act_add_edge(pattern, "e63", ext_grs_NO_EDGE_POS, n_Const1448, n_MultipleAdd5755, 35);
+    ext_grs_edge_t *e_e68 = ext_grs_act_add_edge(pattern, "e68", ext_grs_NO_EDGE_POS, n_VProj1404, n_Vector_Result1_Mul1413, 36);
+    ext_grs_edge_t *e_e67 = ext_grs_act_add_edge(pattern, "e67", ext_grs_NO_EDGE_POS, n_Proj1412, n_Vector_Result1_Mul1413, 37);
+    ext_grs_edge_t *e_pos1_69 = ext_grs_act_add_edge(pattern, "pos1_69", 0, n_Arg_0, n_VProj1404, 38);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1411};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37731, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1459};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37734, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1374};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37737, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1436};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37740, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1388};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37743, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1380};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37746, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1428};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37749, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5752};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37752, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1424};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37755, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1387};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37758, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1435};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37761, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5753};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37764, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1412};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37767, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1460};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37770, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1452};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37773, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5754};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37776, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5755};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37779, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1404};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37782, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1448};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_37785, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Load1458_241 = ext_grs_act_add_node_to_keep(pattern, "Load1458_241", grs_op_Load, mode_T, 0, n_Load1458);
+       ext_grs_node_t *n_VProj1380_242 = ext_grs_act_add_node_to_keep(pattern, "VProj1380_242", grs_op_VProj, mode_F, 1, n_VProj1380);
+       ext_grs_node_t *n_Proj1387_243 = ext_grs_act_add_node_to_keep(pattern, "Proj1387_243", grs_op_Proj, mode_M, 2, n_Proj1387);
+       ext_grs_node_t *n_Proj1460_244 = ext_grs_act_add_node_to_keep(pattern, "Proj1460_244", grs_op_Proj, mode_F, 3, n_Proj1460);
+       ext_grs_node_t *n_Const1448_245 = ext_grs_act_add_node_to_keep(pattern, "Const1448_245", grs_op_Const, mode_Is, 4, n_Const1448);
+       ext_grs_node_t *n_Const1424_246 = ext_grs_act_add_node_to_keep(pattern, "Const1424_246", grs_op_Const, mode_Is, 5, n_Const1424);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 31);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 32);
+       ext_grs_node_t *n_Load1434_247 = ext_grs_act_add_node_to_keep(pattern, "Load1434_247", grs_op_Load, mode_T, 6, n_Load1434);
+       ext_grs_node_t *n_Load1410_248 = ext_grs_act_add_node_to_keep(pattern, "Load1410_248", grs_op_Load, mode_T, 7, n_Load1410);
+       ext_grs_node_t *n_Proj1388_249 = ext_grs_act_add_node_to_keep(pattern, "Proj1388_249", grs_op_Proj, mode_F, 8, n_Proj1388);
+       ext_grs_node_t *n_Arg_0_250 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_250", grs_op_VectorBase, mode_ANY, 9, n_Arg_0);
+       ext_grs_node_t *n_Proj1435_251 = ext_grs_act_add_node_to_keep(pattern, "Proj1435_251", grs_op_Proj, mode_M, 11, n_Proj1435);
+       ext_grs_node_t *n_Arg_1_252 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_252", grs_op_VectorBase, mode_ANY, 10, n_Arg_1);
+       ext_grs_node_t *n_VProj1428_253 = ext_grs_act_add_node_to_keep(pattern, "VProj1428_253", grs_op_VProj, mode_F, 12, n_VProj1428);
+       ext_grs_node_t *n_Vector_op_Block_254 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_254", grs_op_Block, mode_BB, 13, n_Vector_op_Block);
+       ext_grs_node_t *n_Proj1412_255 = ext_grs_act_add_node_to_keep(pattern, "Proj1412_255", grs_op_Proj, mode_F, 15, n_Proj1412);
+       ext_grs_node_t *n_MultipleAdd5754_256 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5754_256", grs_op_MultipleAdd, mode_P, 14, n_MultipleAdd5754);
+       ext_grs_node_t *n_MultipleAdd5753_257 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5753_257", grs_op_MultipleAdd, mode_P, 16, n_MultipleAdd5753);
+       ext_grs_node_t *n_Proj1436_258 = ext_grs_act_add_node_to_keep(pattern, "Proj1436_258", grs_op_Proj, mode_F, 17, n_Proj1436);
+       ext_grs_node_t *n_Proj1411_259 = ext_grs_act_add_node_to_keep(pattern, "Proj1411_259", grs_op_Proj, mode_M, 19, n_Proj1411);
+       ext_grs_node_t *n_MultipleAdd5755_260 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5755_260", grs_op_MultipleAdd, mode_P, 18, n_MultipleAdd5755);
+       ext_grs_node_t *n_Const1374_261 = ext_grs_act_add_node_to_keep(pattern, "Const1374_261", grs_op_Const, mode_Is, 20, n_Const1374);
+       ext_grs_node_t *n_Proj1459_262 = ext_grs_act_add_node_to_keep(pattern, "Proj1459_262", grs_op_Proj, mode_M, 21, n_Proj1459);
+       ext_grs_node_t *n_MultipleAdd5752_263 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5752_263", grs_op_MultipleAdd, mode_P, 22, n_MultipleAdd5752);
+       ext_grs_node_t *n_VProj31_264 = ext_grs_act_add_node_to_keep(pattern, "VProj31_264", grs_op_VProj, mode_F, 33, n_Vector_Result0_Mul1389);
+       ext_grs_node_t *n_Load1386_265 = ext_grs_act_add_node_to_keep(pattern, "Load1386_265", grs_op_Load, mode_T, 25, n_Load1386);
+       ext_grs_node_t *n_VProj1404_266 = ext_grs_act_add_node_to_keep(pattern, "VProj1404_266", grs_op_VProj, mode_F, 24, n_VProj1404);
+       ext_grs_node_t *n_VProj33_267 = ext_grs_act_add_node_to_keep(pattern, "VProj33_267", grs_op_VProj, mode_F, 34, n_Vector_Result3_Mul1461);
+       ext_grs_node_t *n_IR_node5756_268 = ext_grs_act_add_node_to_keep(pattern, "IR_node5756_268", grs_op_IR_node, mode_ANY, 27, n_IR_node5756);
+       ext_grs_node_t *n_VProj35_269 = ext_grs_act_add_node_to_keep(pattern, "VProj35_269", grs_op_VProj, mode_F, 35, n_Vector_Result2_Mul1437);
+       ext_grs_node_t *n_Bad31 = ext_grs_act_add_node(pattern, "Bad31", grs_op_Bad, mode_ANY, 36);
+       ext_grs_node_t *n_VProj37_270 = ext_grs_act_add_node_to_keep(pattern, "VProj37_270", grs_op_VProj, mode_F, 37, n_Vector_Result1_Mul1413);
+       ext_grs_node_t *n_VProj1452_271 = ext_grs_act_add_node_to_keep(pattern, "VProj1452_271", grs_op_VProj, mode_F, 30, n_VProj1452);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 38);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_31_272 = ext_grs_act_add_edge_to_keep(pattern, "pos1_31_272", 0, n_Load1410_248, n_Proj1411_259, 0, e_pos1_31);
+       ext_grs_edge_t *e_pos0_70_273 = ext_grs_act_add_edge(pattern, "pos0_70_273", -1, n_Vector_op_Block_254, n_Vector_op, 39);
+       ext_grs_edge_t *e_pos0_36_274 = ext_grs_act_add_edge_to_keep(pattern, "pos0_36_274", -1, n_Vector_op_Block_254, n_VProj31_264, 1, e_pos0_36);
+       ext_grs_edge_t *e_pos0_71_275 = ext_grs_act_add_edge(pattern, "pos0_71_275", -1, n_Vector_op_Block_254, n_Vector_op_ProjData, 40);
+       ext_grs_edge_t *e_pos0_77_276 = ext_grs_act_add_edge(pattern, "pos0_77_276", -1, n_Vector_op_Block_254, n_Vector_op_ProjM, 41);
+       ext_grs_edge_t *e_pos1_34_277 = ext_grs_act_add_edge_to_keep(pattern, "pos1_34_277", 0, n_Load1386_265, n_Proj1388_249, 2, e_pos1_34);
+       ext_grs_edge_t *e_pos1_32_278 = ext_grs_act_add_edge_to_keep(pattern, "pos1_32_278", 0, n_Load1458_241, n_Proj1459_262, 3, e_pos1_32);
+       ext_grs_edge_t *e_pos1_33_279 = ext_grs_act_add_edge_to_keep(pattern, "pos1_33_279", 0, n_Load1434_247, n_Proj1436_258, 4, e_pos1_33);
+       ext_grs_edge_t *e_pos2_35_280 = ext_grs_act_add_edge_to_keep(pattern, "pos2_35_280", 1, n_MultipleAdd5752_263, n_Load1386_265, 5, e_pos2_35);
+       ext_grs_edge_t *e_pos2_39_281 = ext_grs_act_add_edge_to_keep(pattern, "pos2_39_281", 1, n_MultipleAdd5754_256, n_Load1434_247, 6, e_pos2_39);
+       ext_grs_edge_t *e_pos1_76_282 = ext_grs_act_add_edge(pattern, "pos1_76_282", 0, n_Vector_op, n_Vector_op_ProjM, 42);
+       ext_grs_edge_t *e_pos1_79_283 = ext_grs_act_add_edge(pattern, "pos1_79_283", 0, n_Vector_op_ProjData, n_VProj33_267, 43);
+       ext_grs_edge_t *e_pos2_73_284 = ext_grs_act_add_edge(pattern, "pos2_73_284", 1, n_MultipleAdd5752_263, n_Vector_op, 44);
+       ext_grs_edge_t *e_pos1_78_285 = ext_grs_act_add_edge(pattern, "pos1_78_285", 0, n_Vector_op_ProjData, n_VProj31_264, 45);
+       ext_grs_edge_t *e_pos1_72_286 = ext_grs_act_add_edge(pattern, "pos1_72_286", 0, n_Vector_op, n_Vector_op_ProjData, 46);
+       ext_grs_edge_t *e_pos1_74_287 = ext_grs_act_add_edge(pattern, "pos1_74_287", 0, n_Arg_0_250, n_Vector_op, 47);
+       ext_grs_edge_t *e_pos3_75_288 = ext_grs_act_add_edge(pattern, "pos3_75_288", 2, n_Bad31, n_Vector_op, 48);
+       ext_grs_edge_t *e_pos1_40_289 = ext_grs_act_add_edge_to_keep(pattern, "pos1_40_289", 0, n_Arg_0_250, n_VProj1380_242, 9, e_pos1_40);
+       ext_grs_edge_t *e_pos1_41_290 = ext_grs_act_add_edge_to_keep(pattern, "pos1_41_290", 0, n_Arg_0_250, n_VProj1428_253, 11, e_pos1_41);
+       ext_grs_edge_t *e_e42_291 = ext_grs_act_add_edge_to_keep(pattern, "e42_291", ext_grs_NO_EDGE_POS, n_Arg_1_252, n_MultipleAdd5752_263, 12, e_e42);
+       ext_grs_edge_t *e_e43_292 = ext_grs_act_add_edge_to_keep(pattern, "e43_292", ext_grs_NO_EDGE_POS, n_IR_node5756_268, n_MultipleAdd5752_263, 13, e_e43);
+       ext_grs_edge_t *e_pos0_66_293 = ext_grs_act_add_edge_to_keep(pattern, "pos0_66_293", -1, n_Vector_op_Block_254, n_VProj37_270, 14, e_pos0_66);
+       ext_grs_edge_t *e_pos1_44_294 = ext_grs_act_add_edge_to_keep(pattern, "pos1_44_294", 0, n_Load1386_265, n_Proj1387_243, 15, e_pos1_44);
+       ext_grs_edge_t *e_pos1_45_295 = ext_grs_act_add_edge_to_keep(pattern, "pos1_45_295", 0, n_Load1434_247, n_Proj1435_251, 16, e_pos1_45);
+       ext_grs_edge_t *e_pos2_61_296 = ext_grs_act_add_edge_to_keep(pattern, "pos2_61_296", 1, n_MultipleAdd5753_257, n_Load1410_248, 17, e_pos2_61);
+       ext_grs_edge_t *e_pos2_62_297 = ext_grs_act_add_edge_to_keep(pattern, "pos2_62_297", 1, n_MultipleAdd5755_260, n_Load1458_241, 18, e_pos2_62);
+       ext_grs_edge_t *e_pos1_81_298 = ext_grs_act_add_edge(pattern, "pos1_81_298", 0, n_Vector_op_ProjData, n_VProj37_270, 49);
+       ext_grs_edge_t *e_e49_299 = ext_grs_act_add_edge_to_keep(pattern, "e49_299", ext_grs_NO_EDGE_POS, n_Const1374_261, n_MultipleAdd5753_257, 19, e_e49);
+       ext_grs_edge_t *e_pos1_80_300 = ext_grs_act_add_edge(pattern, "pos1_80_300", 0, n_Vector_op_ProjData, n_VProj35_269, 50);
+       ext_grs_edge_t *e_pos0_52_301 = ext_grs_act_add_edge_to_keep(pattern, "pos0_52_301", -1, n_Vector_op_Block_254, n_VProj35_269, 21, e_pos0_52);
+       ext_grs_edge_t *e_e50_302 = ext_grs_act_add_edge_to_keep(pattern, "e50_302", ext_grs_NO_EDGE_POS, n_Arg_1_252, n_MultipleAdd5753_257, 22, e_e50);
+       ext_grs_edge_t *e_e51_303 = ext_grs_act_add_edge_to_keep(pattern, "e51_303", ext_grs_NO_EDGE_POS, n_IR_node5756_268, n_MultipleAdd5753_257, 23, e_e51);
+       ext_grs_edge_t *e_e58_304 = ext_grs_act_add_edge_to_keep(pattern, "e58_304", ext_grs_NO_EDGE_POS, n_Const1424_246, n_MultipleAdd5754_256, 26, e_e58);
+       ext_grs_edge_t *e_pos1_55_305 = ext_grs_act_add_edge_to_keep(pattern, "pos1_55_305", 0, n_Load1410_248, n_Proj1412_255, 28, e_pos1_55);
+       ext_grs_edge_t *e_e59_306 = ext_grs_act_add_edge_to_keep(pattern, "e59_306", ext_grs_NO_EDGE_POS, n_Arg_1_252, n_MultipleAdd5754_256, 27, e_e59);
+       ext_grs_edge_t *e_pos1_57_307 = ext_grs_act_add_edge_to_keep(pattern, "pos1_57_307", 0, n_Arg_0_250, n_VProj1452_271, 29, e_pos1_57);
+       ext_grs_edge_t *e_pos1_56_308 = ext_grs_act_add_edge_to_keep(pattern, "pos1_56_308", 0, n_Load1458_241, n_Proj1460_244, 30, e_pos1_56);
+       ext_grs_edge_t *e_e60_309 = ext_grs_act_add_edge_to_keep(pattern, "e60_309", ext_grs_NO_EDGE_POS, n_IR_node5756_268, n_MultipleAdd5754_256, 31, e_e60);
+       ext_grs_edge_t *e_pos0_46_310 = ext_grs_act_add_edge_to_keep(pattern, "pos0_46_310", -1, n_Vector_op_Block_254, n_VProj33_267, 33, e_pos0_46);
+       ext_grs_edge_t *e_e65_311 = ext_grs_act_add_edge_to_keep(pattern, "e65_311", ext_grs_NO_EDGE_POS, n_IR_node5756_268, n_MultipleAdd5755_260, 32, e_e65);
+       ext_grs_edge_t *e_e64_312 = ext_grs_act_add_edge_to_keep(pattern, "e64_312", ext_grs_NO_EDGE_POS, n_Arg_1_252, n_MultipleAdd5755_260, 34, e_e64);
+       ext_grs_edge_t *e_e63_313 = ext_grs_act_add_edge_to_keep(pattern, "e63_313", ext_grs_NO_EDGE_POS, n_Const1448_245, n_MultipleAdd5755_260, 35, e_e63);
+       ext_grs_edge_t *e_pos1_69_314 = ext_grs_act_add_edge_to_keep(pattern, "pos1_69_314", 0, n_Arg_0_250, n_VProj1404_266, 38, e_pos1_69);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37961);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37964);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37967);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37970);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37973);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_37976);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* mulps_4_32_am_variant1 */
+
+
+/* functions for evaluation of conditions of action mulps_4_32_am_variant2 */
+static int grs_cond_func_38320(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[19/* Proj1411 */]) == 0;
+}
+static int grs_cond_func_38323(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[21/* Proj1459 */]) == 0;
+}
+static int grs_cond_func_38326(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[20/* Const1374 */])) == 4;
+}
+static int grs_cond_func_38329(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj1436 */]) == 3;
+}
+static int grs_cond_func_38332(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[8/* Proj1388 */]) == 3;
+}
+static int grs_cond_func_38335(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[1/* VProj1380 */]) == 0;
+}
+static int grs_cond_func_38338(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[12/* VProj1428 */]) == 2;
+}
+static int grs_cond_func_38341(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[22/* MultipleAdd5752 */]) == 4;
+}
+static int grs_cond_func_38344(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[5/* Const1424 */])) == 8;
+}
+static int grs_cond_func_38347(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[2/* Proj1387 */]) == 0;
+}
+static int grs_cond_func_38350(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[11/* Proj1435 */]) == 0;
+}
+static int grs_cond_func_38353(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[16/* MultipleAdd5753 */]) == 4;
+}
+static int grs_cond_func_38356(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Proj1412 */]) == 3;
+}
+static int grs_cond_func_38359(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[3/* Proj1460 */]) == 3;
+}
+static int grs_cond_func_38362(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[31/* VProj1452 */]) == 3;
+}
+static int grs_cond_func_38365(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[14/* MultipleAdd5754 */]) == 4;
+}
+static int grs_cond_func_38368(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[18/* MultipleAdd5755 */]) == 4;
+}
+static int grs_cond_func_38371(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[24/* VProj1404 */]) == 1;
+}
+static int grs_cond_func_38374(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[4/* Const1448 */])) == 12;
+}
+
+static void *grs_eval_out_func_38556(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[33/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_38559(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[32/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_38562(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[34/* VProj32 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_38565(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[35/* VProj34 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_38568(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[36/* VProj36 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_38571(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[38/* VProj38 */], 1);
+  return(NULL);
+}
+/* functions for building the pattern of action mulps_4_32_am_variant2 */
+static _inline ext_grs_action_t *grs_action_mulps_4_32_am_variant2_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "mulps_4_32_am_variant2");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Load1458 = ext_grs_act_add_node(pattern, "Load1458", grs_op_Load, mode_T, 0);
+    ext_grs_node_t *n_VProj1380 = ext_grs_act_add_node(pattern, "VProj1380", grs_op_VProj, mode_F, 1);
+    ext_grs_node_t *n_Proj1387 = ext_grs_act_add_node(pattern, "Proj1387", grs_op_Proj, mode_M, 2);
+    ext_grs_node_t *n_Proj1460 = ext_grs_act_add_node(pattern, "Proj1460", grs_op_Proj, mode_F, 3);
+    ext_grs_node_t *n_Const1448 = ext_grs_act_add_node(pattern, "Const1448", grs_op_Const, mode_Is, 4);
+    ext_grs_node_t *n_Const1424 = ext_grs_act_add_node(pattern, "Const1424", grs_op_Const, mode_Is, 5);
+    ext_grs_node_t *n_Load1434 = ext_grs_act_add_node(pattern, "Load1434", grs_op_Load, mode_T, 6);
+    ext_grs_node_t *n_Load1410 = ext_grs_act_add_node(pattern, "Load1410", grs_op_Load, mode_T, 7);
+    ext_grs_node_t *n_Proj1388 = ext_grs_act_add_node(pattern, "Proj1388", grs_op_Proj, mode_F, 8);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 9);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 10);
+    ext_grs_node_t *n_Proj1435 = ext_grs_act_add_node(pattern, "Proj1435", grs_op_Proj, mode_M, 11);
+    ext_grs_node_t *n_VProj1428 = ext_grs_act_add_node(pattern, "VProj1428", grs_op_VProj, mode_F, 12);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 13);
+    ext_grs_node_t *n_MultipleAdd5754 = ext_grs_act_add_node(pattern, "MultipleAdd5754", grs_op_MultipleAdd, mode_P, 14);
+    ext_grs_node_t *n_Proj1412 = ext_grs_act_add_node(pattern, "Proj1412", grs_op_Proj, mode_F, 15);
+    ext_grs_node_t *n_MultipleAdd5753 = ext_grs_act_add_node(pattern, "MultipleAdd5753", grs_op_MultipleAdd, mode_P, 16);
+    ext_grs_node_t *n_Proj1436 = ext_grs_act_add_node(pattern, "Proj1436", grs_op_Proj, mode_F, 17);
+    ext_grs_node_t *n_MultipleAdd5755 = ext_grs_act_add_node(pattern, "MultipleAdd5755", grs_op_MultipleAdd, mode_P, 18);
+    ext_grs_node_t *n_Proj1411 = ext_grs_act_add_node(pattern, "Proj1411", grs_op_Proj, mode_M, 19);
+    ext_grs_node_t *n_Const1374 = ext_grs_act_add_node(pattern, "Const1374", grs_op_Const, mode_Is, 20);
+    ext_grs_node_t *n_Proj1459 = ext_grs_act_add_node(pattern, "Proj1459", grs_op_Proj, mode_M, 21);
+    ext_grs_node_t *n_MultipleAdd5752 = ext_grs_act_add_node(pattern, "MultipleAdd5752", grs_op_MultipleAdd, mode_P, 22);
+    ext_grs_node_t *n_Vector_Result0_Mul1389 = ext_grs_act_add_node(pattern, "Vector_Result0_Mul1389", grs_op_Mul, mode_F, 23);
+    ext_grs_node_t *n_VProj1404 = ext_grs_act_add_node(pattern, "VProj1404", grs_op_VProj, mode_F, 24);
+    ext_grs_node_t *n_Load1386 = ext_grs_act_add_node(pattern, "Load1386", grs_op_Load, mode_T, 25);
+    ext_grs_node_t *n_Vector_Result3_Mul1461 = ext_grs_act_add_node(pattern, "Vector_Result3_Mul1461", grs_op_Mul, mode_F, 26);
+    ext_grs_node_t *n_IR_node5757 = ext_grs_act_add_node(pattern, "IR_node5757", grs_op_IR_node, mode_ANY, 27);
+    ext_grs_node_t *n_IR_node5756 = ext_grs_act_add_node(pattern, "IR_node5756", grs_op_IR_node, mode_ANY, 28);
+    ext_grs_node_t *n_Vector_Result2_Mul1437 = ext_grs_act_add_node(pattern, "Vector_Result2_Mul1437", grs_op_Mul, mode_F, 29);
+    ext_grs_node_t *n_Vector_Result1_Mul1413 = ext_grs_act_add_node(pattern, "Vector_Result1_Mul1413", grs_op_Mul, mode_F, 30);
+    ext_grs_node_t *n_VProj1452 = ext_grs_act_add_node(pattern, "VProj1452", grs_op_VProj, mode_F, 31);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e70 = ext_grs_act_add_edge(pattern, "e70", ext_grs_NO_EDGE_POS, n_IR_node5757, n_MultipleAdd5755, 0);
+    ext_grs_edge_t *e_e72 = ext_grs_act_add_edge(pattern, "e72", ext_grs_NO_EDGE_POS, n_Proj1412, n_Vector_Result1_Mul1413, 1);
+    ext_grs_edge_t *e_pos0_37 = ext_grs_act_add_edge(pattern, "pos0_37", -1, n_Vector_op_Block, n_Vector_Result0_Mul1389, 2);
+    ext_grs_edge_t *e_pos0_71 = ext_grs_act_add_edge(pattern, "pos0_71", -1, n_Vector_op_Block, n_Vector_Result1_Mul1413, 3);
+    ext_grs_edge_t *e_pos1_34 = ext_grs_act_add_edge(pattern, "pos1_34", 0, n_Load1434, n_Proj1436, 4);
+    ext_grs_edge_t *e_e73 = ext_grs_act_add_edge(pattern, "e73", ext_grs_NO_EDGE_POS, n_VProj1404, n_Vector_Result1_Mul1413, 5);
+    ext_grs_edge_t *e_pos1_35 = ext_grs_act_add_edge(pattern, "pos1_35", 0, n_Load1386, n_Proj1388, 6);
+    ext_grs_edge_t *e_pos1_32 = ext_grs_act_add_edge(pattern, "pos1_32", 0, n_Load1410, n_Proj1411, 7);
+    ext_grs_edge_t *e_pos1_33 = ext_grs_act_add_edge(pattern, "pos1_33", 0, n_Load1458, n_Proj1459, 8);
+    ext_grs_edge_t *e_pos2_36 = ext_grs_act_add_edge(pattern, "pos2_36", 1, n_MultipleAdd5752, n_Load1386, 9);
+    ext_grs_edge_t *e_pos1_74 = ext_grs_act_add_edge(pattern, "pos1_74", 0, n_Arg_0, n_VProj1404, 10);
+    ext_grs_edge_t *e_e38 = ext_grs_act_add_edge(pattern, "e38", ext_grs_NO_EDGE_POS, n_Proj1388, n_Vector_Result0_Mul1389, 11);
+    ext_grs_edge_t *e_e39 = ext_grs_act_add_edge(pattern, "e39", ext_grs_NO_EDGE_POS, n_VProj1380, n_Vector_Result0_Mul1389, 12);
+    ext_grs_edge_t *e_pos1_41 = ext_grs_act_add_edge(pattern, "pos1_41", 0, n_Arg_0, n_VProj1380, 13);
+    ext_grs_edge_t *e_e44 = ext_grs_act_add_edge(pattern, "e44", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5752, 14);
+    ext_grs_edge_t *e_pos1_42 = ext_grs_act_add_edge(pattern, "pos1_42", 0, n_Arg_0, n_VProj1428, 15);
+    ext_grs_edge_t *e_e45 = ext_grs_act_add_edge(pattern, "e45", ext_grs_NO_EDGE_POS, n_IR_node5757, n_MultipleAdd5752, 16);
+    ext_grs_edge_t *e_e43 = ext_grs_act_add_edge(pattern, "e43", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5752, 17);
+    ext_grs_edge_t *e_pos1_47 = ext_grs_act_add_edge(pattern, "pos1_47", 0, n_Load1434, n_Proj1435, 18);
+    ext_grs_edge_t *e_pos1_46 = ext_grs_act_add_edge(pattern, "pos1_46", 0, n_Load1386, n_Proj1387, 19);
+    ext_grs_edge_t *e_pos2_65 = ext_grs_act_add_edge(pattern, "pos2_65", 1, n_MultipleAdd5753, n_Load1410, 20);
+    ext_grs_edge_t *e_pos2_66 = ext_grs_act_add_edge(pattern, "pos2_66", 1, n_MultipleAdd5755, n_Load1458, 21);
+    ext_grs_edge_t *e_e49 = ext_grs_act_add_edge(pattern, "e49", ext_grs_NO_EDGE_POS, n_Proj1460, n_Vector_Result3_Mul1461, 22);
+    ext_grs_edge_t *e_e50 = ext_grs_act_add_edge(pattern, "e50", ext_grs_NO_EDGE_POS, n_VProj1452, n_Vector_Result3_Mul1461, 23);
+    ext_grs_edge_t *e_e52 = ext_grs_act_add_edge(pattern, "e52", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5753, 24);
+    ext_grs_edge_t *e_e51 = ext_grs_act_add_edge(pattern, "e51", ext_grs_NO_EDGE_POS, n_Const1374, n_MultipleAdd5753, 25);
+    ext_grs_edge_t *e_e54 = ext_grs_act_add_edge(pattern, "e54", ext_grs_NO_EDGE_POS, n_IR_node5757, n_MultipleAdd5753, 26);
+    ext_grs_edge_t *e_e53 = ext_grs_act_add_edge(pattern, "e53", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5753, 27);
+    ext_grs_edge_t *e_e56 = ext_grs_act_add_edge(pattern, "e56", ext_grs_NO_EDGE_POS, n_Proj1436, n_Vector_Result2_Mul1437, 28);
+    ext_grs_edge_t *e_pos0_55 = ext_grs_act_add_edge(pattern, "pos0_55", -1, n_Vector_op_Block, n_Vector_Result2_Mul1437, 29);
+    ext_grs_edge_t *e_e57 = ext_grs_act_add_edge(pattern, "e57", ext_grs_NO_EDGE_POS, n_VProj1428, n_Vector_Result2_Mul1437, 30);
+    ext_grs_edge_t *e_pos1_59 = ext_grs_act_add_edge(pattern, "pos1_59", 0, n_Load1458, n_Proj1460, 31);
+    ext_grs_edge_t *e_pos1_58 = ext_grs_act_add_edge(pattern, "pos1_58", 0, n_Load1410, n_Proj1412, 32);
+    ext_grs_edge_t *e_e61 = ext_grs_act_add_edge(pattern, "e61", ext_grs_NO_EDGE_POS, n_Const1424, n_MultipleAdd5754, 33);
+    ext_grs_edge_t *e_e64 = ext_grs_act_add_edge(pattern, "e64", ext_grs_NO_EDGE_POS, n_IR_node5757, n_MultipleAdd5754, 34);
+    ext_grs_edge_t *e_e63 = ext_grs_act_add_edge(pattern, "e63", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5754, 35);
+    ext_grs_edge_t *e_pos0_48 = ext_grs_act_add_edge(pattern, "pos0_48", -1, n_Vector_op_Block, n_Vector_Result3_Mul1461, 36);
+    ext_grs_edge_t *e_e62 = ext_grs_act_add_edge(pattern, "e62", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5754, 37);
+    ext_grs_edge_t *e_e69 = ext_grs_act_add_edge(pattern, "e69", ext_grs_NO_EDGE_POS, n_IR_node5756, n_MultipleAdd5755, 38);
+    ext_grs_edge_t *e_e68 = ext_grs_act_add_edge(pattern, "e68", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5755, 39);
+    ext_grs_edge_t *e_e67 = ext_grs_act_add_edge(pattern, "e67", ext_grs_NO_EDGE_POS, n_Const1448, n_MultipleAdd5755, 40);
+    ext_grs_edge_t *e_pos1_60 = ext_grs_act_add_edge(pattern, "pos1_60", 0, n_Arg_0, n_VProj1452, 41);
+    ext_grs_edge_t *e_pos2_40 = ext_grs_act_add_edge(pattern, "pos2_40", 1, n_MultipleAdd5754, n_Load1434, 42);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1411};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38320, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1459};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38323, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1374};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38326, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1436};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38329, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1388};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38332, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1380};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38335, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1428};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38338, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5752};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38341, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1424};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38344, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1387};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38347, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1435};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38350, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5753};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38353, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1412};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38356, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj1460};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38359, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1452};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38362, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5754};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38365, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5755};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38368, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1404};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38371, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const1448};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_38374, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Load1458_315 = ext_grs_act_add_node_to_keep(pattern, "Load1458_315", grs_op_Load, mode_T, 0, n_Load1458);
+       ext_grs_node_t *n_VProj1380_316 = ext_grs_act_add_node_to_keep(pattern, "VProj1380_316", grs_op_VProj, mode_F, 1, n_VProj1380);
+       ext_grs_node_t *n_Proj1387_317 = ext_grs_act_add_node_to_keep(pattern, "Proj1387_317", grs_op_Proj, mode_M, 2, n_Proj1387);
+       ext_grs_node_t *n_Proj1460_318 = ext_grs_act_add_node_to_keep(pattern, "Proj1460_318", grs_op_Proj, mode_F, 3, n_Proj1460);
+       ext_grs_node_t *n_Const1448_319 = ext_grs_act_add_node_to_keep(pattern, "Const1448_319", grs_op_Const, mode_Is, 4, n_Const1448);
+       ext_grs_node_t *n_Const1424_320 = ext_grs_act_add_node_to_keep(pattern, "Const1424_320", grs_op_Const, mode_Is, 5, n_Const1424);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 32);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 33);
+       ext_grs_node_t *n_Load1434_321 = ext_grs_act_add_node_to_keep(pattern, "Load1434_321", grs_op_Load, mode_T, 6, n_Load1434);
+       ext_grs_node_t *n_Load1410_322 = ext_grs_act_add_node_to_keep(pattern, "Load1410_322", grs_op_Load, mode_T, 7, n_Load1410);
+       ext_grs_node_t *n_Proj1388_323 = ext_grs_act_add_node_to_keep(pattern, "Proj1388_323", grs_op_Proj, mode_F, 8, n_Proj1388);
+       ext_grs_node_t *n_Arg_0_324 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_324", grs_op_VectorBase, mode_ANY, 9, n_Arg_0);
+       ext_grs_node_t *n_Proj1435_325 = ext_grs_act_add_node_to_keep(pattern, "Proj1435_325", grs_op_Proj, mode_M, 11, n_Proj1435);
+       ext_grs_node_t *n_Arg_1_326 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_326", grs_op_VectorBase, mode_ANY, 10, n_Arg_1);
+       ext_grs_node_t *n_VProj1428_327 = ext_grs_act_add_node_to_keep(pattern, "VProj1428_327", grs_op_VProj, mode_F, 12, n_VProj1428);
+       ext_grs_node_t *n_Vector_op_Block_328 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_328", grs_op_Block, mode_BB, 13, n_Vector_op_Block);
+       ext_grs_node_t *n_Proj1412_329 = ext_grs_act_add_node_to_keep(pattern, "Proj1412_329", grs_op_Proj, mode_F, 15, n_Proj1412);
+       ext_grs_node_t *n_MultipleAdd5754_330 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5754_330", grs_op_MultipleAdd, mode_P, 14, n_MultipleAdd5754);
+       ext_grs_node_t *n_MultipleAdd5753_331 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5753_331", grs_op_MultipleAdd, mode_P, 16, n_MultipleAdd5753);
+       ext_grs_node_t *n_Proj1436_332 = ext_grs_act_add_node_to_keep(pattern, "Proj1436_332", grs_op_Proj, mode_F, 17, n_Proj1436);
+       ext_grs_node_t *n_Proj1411_333 = ext_grs_act_add_node_to_keep(pattern, "Proj1411_333", grs_op_Proj, mode_M, 19, n_Proj1411);
+       ext_grs_node_t *n_MultipleAdd5755_334 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5755_334", grs_op_MultipleAdd, mode_P, 18, n_MultipleAdd5755);
+       ext_grs_node_t *n_Const1374_335 = ext_grs_act_add_node_to_keep(pattern, "Const1374_335", grs_op_Const, mode_Is, 20, n_Const1374);
+       ext_grs_node_t *n_Proj1459_336 = ext_grs_act_add_node_to_keep(pattern, "Proj1459_336", grs_op_Proj, mode_M, 21, n_Proj1459);
+       ext_grs_node_t *n_MultipleAdd5752_337 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5752_337", grs_op_MultipleAdd, mode_P, 22, n_MultipleAdd5752);
+       ext_grs_node_t *n_VProj32_338 = ext_grs_act_add_node_to_keep(pattern, "VProj32_338", grs_op_VProj, mode_F, 34, n_Vector_Result0_Mul1389);
+       ext_grs_node_t *n_Load1386_339 = ext_grs_act_add_node_to_keep(pattern, "Load1386_339", grs_op_Load, mode_T, 25, n_Load1386);
+       ext_grs_node_t *n_VProj1404_340 = ext_grs_act_add_node_to_keep(pattern, "VProj1404_340", grs_op_VProj, mode_F, 24, n_VProj1404);
+       ext_grs_node_t *n_VProj34_341 = ext_grs_act_add_node_to_keep(pattern, "VProj34_341", grs_op_VProj, mode_F, 35, n_Vector_Result3_Mul1461);
+       ext_grs_node_t *n_IR_node5757_342 = ext_grs_act_add_node_to_keep(pattern, "IR_node5757_342", grs_op_IR_node, mode_ANY, 27, n_IR_node5757);
+       ext_grs_node_t *n_IR_node5756_343 = ext_grs_act_add_node_to_keep(pattern, "IR_node5756_343", grs_op_IR_node, mode_ANY, 28, n_IR_node5756);
+       ext_grs_node_t *n_VProj36_344 = ext_grs_act_add_node_to_keep(pattern, "VProj36_344", grs_op_VProj, mode_F, 36, n_Vector_Result2_Mul1437);
+       ext_grs_node_t *n_Bad32 = ext_grs_act_add_node(pattern, "Bad32", grs_op_Bad, mode_ANY, 37);
+       ext_grs_node_t *n_VProj38_345 = ext_grs_act_add_node_to_keep(pattern, "VProj38_345", grs_op_VProj, mode_F, 38, n_Vector_Result1_Mul1413);
+       ext_grs_node_t *n_VProj1452_346 = ext_grs_act_add_node_to_keep(pattern, "VProj1452_346", grs_op_VProj, mode_F, 31, n_VProj1452);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 39);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_e70_347 = ext_grs_act_add_edge_to_keep(pattern, "e70_347", ext_grs_NO_EDGE_POS, n_IR_node5757_342, n_MultipleAdd5755_334, 0, e_e70);
+       ext_grs_edge_t *e_pos0_37_348 = ext_grs_act_add_edge_to_keep(pattern, "pos0_37_348", -1, n_Vector_op_Block_328, n_VProj32_338, 2, e_pos0_37);
+       ext_grs_edge_t *e_pos0_71_349 = ext_grs_act_add_edge_to_keep(pattern, "pos0_71_349", -1, n_Vector_op_Block_328, n_VProj38_345, 3, e_pos0_71);
+       ext_grs_edge_t *e_pos0_75_350 = ext_grs_act_add_edge(pattern, "pos0_75_350", -1, n_Vector_op_Block_328, n_Vector_op, 43);
+       ext_grs_edge_t *e_pos0_76_351 = ext_grs_act_add_edge(pattern, "pos0_76_351", -1, n_Vector_op_Block_328, n_Vector_op_ProjData, 44);
+       ext_grs_edge_t *e_pos1_34_352 = ext_grs_act_add_edge_to_keep(pattern, "pos1_34_352", 0, n_Load1434_321, n_Proj1436_332, 4, e_pos1_34);
+       ext_grs_edge_t *e_pos1_35_353 = ext_grs_act_add_edge_to_keep(pattern, "pos1_35_353", 0, n_Load1386_339, n_Proj1388_323, 6, e_pos1_35);
+       ext_grs_edge_t *e_pos1_32_354 = ext_grs_act_add_edge_to_keep(pattern, "pos1_32_354", 0, n_Load1410_322, n_Proj1411_333, 7, e_pos1_32);
+       ext_grs_edge_t *e_pos1_33_355 = ext_grs_act_add_edge_to_keep(pattern, "pos1_33_355", 0, n_Load1458_315, n_Proj1459_336, 8, e_pos1_33);
+       ext_grs_edge_t *e_pos2_36_356 = ext_grs_act_add_edge_to_keep(pattern, "pos2_36_356", 1, n_MultipleAdd5752_337, n_Load1386_339, 9, e_pos2_36);
+       ext_grs_edge_t *e_pos1_77_357 = ext_grs_act_add_edge(pattern, "pos1_77_357", 0, n_Vector_op, n_Vector_op_ProjData, 45);
+       ext_grs_edge_t *e_pos1_79_358 = ext_grs_act_add_edge(pattern, "pos1_79_358", 0, n_Arg_0_324, n_Vector_op, 46);
+       ext_grs_edge_t *e_pos2_78_359 = ext_grs_act_add_edge(pattern, "pos2_78_359", 1, n_MultipleAdd5752_337, n_Vector_op, 47);
+       ext_grs_edge_t *e_pos1_74_360 = ext_grs_act_add_edge_to_keep(pattern, "pos1_74_360", 0, n_Arg_0_324, n_VProj1404_340, 10, e_pos1_74);
+       ext_grs_edge_t *e_pos1_41_361 = ext_grs_act_add_edge_to_keep(pattern, "pos1_41_361", 0, n_Arg_0_324, n_VProj1380_316, 13, e_pos1_41);
+       ext_grs_edge_t *e_e44_362 = ext_grs_act_add_edge_to_keep(pattern, "e44_362", ext_grs_NO_EDGE_POS, n_IR_node5756_343, n_MultipleAdd5752_337, 14, e_e44);
+       ext_grs_edge_t *e_pos1_42_363 = ext_grs_act_add_edge_to_keep(pattern, "pos1_42_363", 0, n_Arg_0_324, n_VProj1428_327, 15, e_pos1_42);
+       ext_grs_edge_t *e_e45_364 = ext_grs_act_add_edge_to_keep(pattern, "e45_364", ext_grs_NO_EDGE_POS, n_IR_node5757_342, n_MultipleAdd5752_337, 16, e_e45);
+       ext_grs_edge_t *e_e43_365 = ext_grs_act_add_edge_to_keep(pattern, "e43_365", ext_grs_NO_EDGE_POS, n_Arg_1_326, n_MultipleAdd5752_337, 17, e_e43);
+       ext_grs_edge_t *e_pos1_47_366 = ext_grs_act_add_edge_to_keep(pattern, "pos1_47_366", 0, n_Load1434_321, n_Proj1435_325, 18, e_pos1_47);
+       ext_grs_edge_t *e_pos1_46_367 = ext_grs_act_add_edge_to_keep(pattern, "pos1_46_367", 0, n_Load1386_339, n_Proj1387_317, 19, e_pos1_46);
+       ext_grs_edge_t *e_pos2_65_368 = ext_grs_act_add_edge_to_keep(pattern, "pos2_65_368", 1, n_MultipleAdd5753_331, n_Load1410_322, 20, e_pos2_65);
+       ext_grs_edge_t *e_pos1_86_369 = ext_grs_act_add_edge(pattern, "pos1_86_369", 0, n_Vector_op_ProjData, n_VProj38_345, 48);
+       ext_grs_edge_t *e_pos2_66_370 = ext_grs_act_add_edge_to_keep(pattern, "pos2_66_370", 1, n_MultipleAdd5755_334, n_Load1458_315, 21, e_pos2_66);
+       ext_grs_edge_t *e_pos1_85_371 = ext_grs_act_add_edge(pattern, "pos1_85_371", 0, n_Vector_op_ProjData, n_VProj36_344, 49);
+       ext_grs_edge_t *e_pos1_84_372 = ext_grs_act_add_edge(pattern, "pos1_84_372", 0, n_Vector_op_ProjData, n_VProj34_341, 50);
+       ext_grs_edge_t *e_pos3_80_373 = ext_grs_act_add_edge(pattern, "pos3_80_373", 2, n_Bad32, n_Vector_op, 51);
+       ext_grs_edge_t *e_pos1_83_374 = ext_grs_act_add_edge(pattern, "pos1_83_374", 0, n_Vector_op_ProjData, n_VProj32_338, 52);
+       ext_grs_edge_t *e_pos1_81_375 = ext_grs_act_add_edge(pattern, "pos1_81_375", 0, n_Vector_op, n_Vector_op_ProjM, 53);
+       ext_grs_edge_t *e_e52_376 = ext_grs_act_add_edge_to_keep(pattern, "e52_376", ext_grs_NO_EDGE_POS, n_Arg_1_326, n_MultipleAdd5753_331, 24, e_e52);
+       ext_grs_edge_t *e_e51_377 = ext_grs_act_add_edge_to_keep(pattern, "e51_377", ext_grs_NO_EDGE_POS, n_Const1374_335, n_MultipleAdd5753_331, 25, e_e51);
+       ext_grs_edge_t *e_e54_378 = ext_grs_act_add_edge_to_keep(pattern, "e54_378", ext_grs_NO_EDGE_POS, n_IR_node5757_342, n_MultipleAdd5753_331, 26, e_e54);
+       ext_grs_edge_t *e_e53_379 = ext_grs_act_add_edge_to_keep(pattern, "e53_379", ext_grs_NO_EDGE_POS, n_IR_node5756_343, n_MultipleAdd5753_331, 27, e_e53);
+       ext_grs_edge_t *e_pos0_55_380 = ext_grs_act_add_edge_to_keep(pattern, "pos0_55_380", -1, n_Vector_op_Block_328, n_VProj36_344, 29, e_pos0_55);
+       ext_grs_edge_t *e_pos1_59_381 = ext_grs_act_add_edge_to_keep(pattern, "pos1_59_381", 0, n_Load1458_315, n_Proj1460_318, 31, e_pos1_59);
+       ext_grs_edge_t *e_pos1_58_382 = ext_grs_act_add_edge_to_keep(pattern, "pos1_58_382", 0, n_Load1410_322, n_Proj1412_329, 32, e_pos1_58);
+       ext_grs_edge_t *e_e61_383 = ext_grs_act_add_edge_to_keep(pattern, "e61_383", ext_grs_NO_EDGE_POS, n_Const1424_320, n_MultipleAdd5754_330, 33, e_e61);
+       ext_grs_edge_t *e_e64_384 = ext_grs_act_add_edge_to_keep(pattern, "e64_384", ext_grs_NO_EDGE_POS, n_IR_node5757_342, n_MultipleAdd5754_330, 34, e_e64);
+       ext_grs_edge_t *e_pos0_48_385 = ext_grs_act_add_edge_to_keep(pattern, "pos0_48_385", -1, n_Vector_op_Block_328, n_VProj34_341, 36, e_pos0_48);
+       ext_grs_edge_t *e_e63_386 = ext_grs_act_add_edge_to_keep(pattern, "e63_386", ext_grs_NO_EDGE_POS, n_IR_node5756_343, n_MultipleAdd5754_330, 35, e_e63);
+       ext_grs_edge_t *e_e62_387 = ext_grs_act_add_edge_to_keep(pattern, "e62_387", ext_grs_NO_EDGE_POS, n_Arg_1_326, n_MultipleAdd5754_330, 37, e_e62);
+       ext_grs_edge_t *e_e69_388 = ext_grs_act_add_edge_to_keep(pattern, "e69_388", ext_grs_NO_EDGE_POS, n_IR_node5756_343, n_MultipleAdd5755_334, 38, e_e69);
+       ext_grs_edge_t *e_e68_389 = ext_grs_act_add_edge_to_keep(pattern, "e68_389", ext_grs_NO_EDGE_POS, n_Arg_1_326, n_MultipleAdd5755_334, 39, e_e68);
+       ext_grs_edge_t *e_e67_390 = ext_grs_act_add_edge_to_keep(pattern, "e67_390", ext_grs_NO_EDGE_POS, n_Const1448_319, n_MultipleAdd5755_334, 40, e_e67);
+       ext_grs_edge_t *e_pos2_40_391 = ext_grs_act_add_edge_to_keep(pattern, "pos2_40_391", 1, n_MultipleAdd5754_330, n_Load1434_321, 42, e_pos2_40);
+       ext_grs_edge_t *e_pos1_60_392 = ext_grs_act_add_edge_to_keep(pattern, "pos1_60_392", 0, n_Arg_0_324, n_VProj1452_346, 41, e_pos1_60);
+       ext_grs_edge_t *e_pos0_82_393 = ext_grs_act_add_edge(pattern, "pos0_82_393", -1, n_Vector_op_Block_328, n_Vector_op_ProjM, 54);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38556);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38559);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38562);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38565);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38568);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_38571);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* mulps_4_32_am_variant2 */
+
+
+/* functions for evaluation of conditions of action mulps_4_32_variant0 */
+static int grs_cond_func_36719(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[6/* VProj1209 */]) == 3;
+}
+static int grs_cond_func_36722(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[9/* VProj1217 */]) == 3;
+}
+static int grs_cond_func_36725(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[8/* VProj1169 */]) == 1;
+}
+static int grs_cond_func_36728(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[10/* VProj1137 */]) == 0;
+}
+static int grs_cond_func_36731(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[11/* VProj1185 */]) == 2;
+}
+static int grs_cond_func_36734(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[4/* VProj1193 */]) == 2;
+}
+static int grs_cond_func_36737(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[14/* VProj1145 */]) == 0;
+}
+static int grs_cond_func_36740(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[12/* VProj1161 */]) == 1;
+}
+
+static void *grs_eval_out_func_36846(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[16/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_36849(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[17/* VProj15 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_36852(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[15/* VProj17 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_36855(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[18/* VProj19 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_36858(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[20/* VProj21 */], 1);
+  return(NULL);
+}
+/* functions for building the pattern of action mulps_4_32_variant0 */
+static _inline ext_grs_action_t *grs_action_mulps_4_32_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "mulps_4_32_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 0);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 1);
+    ext_grs_node_t *n_Vector_Result2_Mul1194 = ext_grs_act_add_node(pattern, "Vector_Result2_Mul1194", grs_op_Mul, mode_F, 2);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 3);
+    ext_grs_node_t *n_VProj1193 = ext_grs_act_add_node(pattern, "VProj1193", grs_op_VProj, mode_F, 4);
+    ext_grs_node_t *n_Vector_Result3_Mul1218 = ext_grs_act_add_node(pattern, "Vector_Result3_Mul1218", grs_op_Mul, mode_F, 5);
+    ext_grs_node_t *n_VProj1209 = ext_grs_act_add_node(pattern, "VProj1209", grs_op_VProj, mode_F, 6);
+    ext_grs_node_t *n_Vector_Result0_Mul1146 = ext_grs_act_add_node(pattern, "Vector_Result0_Mul1146", grs_op_Mul, mode_F, 7);
+    ext_grs_node_t *n_VProj1169 = ext_grs_act_add_node(pattern, "VProj1169", grs_op_VProj, mode_F, 8);
+    ext_grs_node_t *n_VProj1217 = ext_grs_act_add_node(pattern, "VProj1217", grs_op_VProj, mode_F, 9);
+    ext_grs_node_t *n_VProj1137 = ext_grs_act_add_node(pattern, "VProj1137", grs_op_VProj, mode_F, 10);
+    ext_grs_node_t *n_VProj1185 = ext_grs_act_add_node(pattern, "VProj1185", grs_op_VProj, mode_F, 11);
+    ext_grs_node_t *n_VProj1161 = ext_grs_act_add_node(pattern, "VProj1161", grs_op_VProj, mode_F, 12);
+    ext_grs_node_t *n_Vector_Result1_Mul1170 = ext_grs_act_add_node(pattern, "Vector_Result1_Mul1170", grs_op_Mul, mode_F, 13);
+    ext_grs_node_t *n_VProj1145 = ext_grs_act_add_node(pattern, "VProj1145", grs_op_VProj, mode_F, 14);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e33 = ext_grs_act_add_edge(pattern, "e33", ext_grs_NO_EDGE_POS, n_VProj1161, n_Vector_Result1_Mul1170, 0);
+    ext_grs_edge_t *e_pos1_30 = ext_grs_act_add_edge(pattern, "pos1_30", 0, n_Arg_1, n_VProj1145, 1);
+    ext_grs_edge_t *e_pos0_15 = ext_grs_act_add_edge(pattern, "pos0_15", -1, n_Vector_op_Block, n_Vector_Result3_Mul1218, 2);
+    ext_grs_edge_t *e_pos0_31 = ext_grs_act_add_edge(pattern, "pos0_31", -1, n_Vector_op_Block, n_Vector_Result1_Mul1170, 3);
+    ext_grs_edge_t *e_e32 = ext_grs_act_add_edge(pattern, "e32", ext_grs_NO_EDGE_POS, n_VProj1169, n_Vector_Result1_Mul1170, 4);
+    ext_grs_edge_t *e_pos1_34 = ext_grs_act_add_edge(pattern, "pos1_34", 0, n_Arg_0, n_VProj1161, 5);
+    ext_grs_edge_t *e_e16 = ext_grs_act_add_edge(pattern, "e16", ext_grs_NO_EDGE_POS, n_VProj1217, n_Vector_Result3_Mul1218, 6);
+    ext_grs_edge_t *e_e17 = ext_grs_act_add_edge(pattern, "e17", ext_grs_NO_EDGE_POS, n_VProj1209, n_Vector_Result3_Mul1218, 7);
+    ext_grs_edge_t *e_e19 = ext_grs_act_add_edge(pattern, "e19", ext_grs_NO_EDGE_POS, n_VProj1193, n_Vector_Result2_Mul1194, 8);
+    ext_grs_edge_t *e_pos0_18 = ext_grs_act_add_edge(pattern, "pos0_18", -1, n_Vector_op_Block, n_Vector_Result2_Mul1194, 9);
+    ext_grs_edge_t *e_e20 = ext_grs_act_add_edge(pattern, "e20", ext_grs_NO_EDGE_POS, n_VProj1185, n_Vector_Result2_Mul1194, 10);
+    ext_grs_edge_t *e_pos0_23 = ext_grs_act_add_edge(pattern, "pos0_23", -1, n_Vector_op_Block, n_Vector_Result0_Mul1146, 11);
+    ext_grs_edge_t *e_e24 = ext_grs_act_add_edge(pattern, "e24", ext_grs_NO_EDGE_POS, n_VProj1145, n_Vector_Result0_Mul1146, 12);
+    ext_grs_edge_t *e_e25 = ext_grs_act_add_edge(pattern, "e25", ext_grs_NO_EDGE_POS, n_VProj1137, n_Vector_Result0_Mul1146, 13);
+    ext_grs_edge_t *e_pos1_21 = ext_grs_act_add_edge(pattern, "pos1_21", 0, n_Arg_0, n_VProj1209, 14);
+    ext_grs_edge_t *e_pos1_22 = ext_grs_act_add_edge(pattern, "pos1_22", 0, n_Arg_1, n_VProj1217, 15);
+    ext_grs_edge_t *e_pos1_26 = ext_grs_act_add_edge(pattern, "pos1_26", 0, n_Arg_1, n_VProj1169, 16);
+    ext_grs_edge_t *e_pos1_27 = ext_grs_act_add_edge(pattern, "pos1_27", 0, n_Arg_0, n_VProj1137, 17);
+    ext_grs_edge_t *e_pos1_28 = ext_grs_act_add_edge(pattern, "pos1_28", 0, n_Arg_0, n_VProj1185, 18);
+    ext_grs_edge_t *e_pos1_29 = ext_grs_act_add_edge(pattern, "pos1_29", 0, n_Arg_1, n_VProj1193, 19);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1209};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36719, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1217};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36722, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1169};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36725, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1137};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36728, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1185};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36731, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1193};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36734, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1145};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36737, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj1161};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36740, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Arg_0_394 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_394", grs_op_VectorBase, mode_ANY, 0, n_Arg_0);
+       ext_grs_node_t *n_Arg_1_395 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_395", grs_op_VectorBase, mode_ANY, 1, n_Arg_1);
+       ext_grs_node_t *n_VProj17_396 = ext_grs_act_add_node_to_keep(pattern, "VProj17_396", grs_op_VProj, mode_F, 15, n_Vector_Result2_Mul1194);
+       ext_grs_node_t *n_Vector_op_Block_397 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_397", grs_op_Block, mode_BB, 3, n_Vector_op_Block);
+       ext_grs_node_t *n_VProj1193_398 = ext_grs_act_add_node_to_keep(pattern, "VProj1193_398", grs_op_VProj, mode_F, 4, n_VProj1193);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 16);
+       ext_grs_node_t *n_VProj15_399 = ext_grs_act_add_node_to_keep(pattern, "VProj15_399", grs_op_VProj, mode_F, 17, n_Vector_Result3_Mul1218);
+       ext_grs_node_t *n_VProj1209_400 = ext_grs_act_add_node_to_keep(pattern, "VProj1209_400", grs_op_VProj, mode_F, 6, n_VProj1209);
+       ext_grs_node_t *n_VProj19_401 = ext_grs_act_add_node_to_keep(pattern, "VProj19_401", grs_op_VProj, mode_F, 18, n_Vector_Result0_Mul1146);
+       ext_grs_node_t *n_VProj1169_402 = ext_grs_act_add_node_to_keep(pattern, "VProj1169_402", grs_op_VProj, mode_F, 8, n_VProj1169);
+       ext_grs_node_t *n_VProj1217_403 = ext_grs_act_add_node_to_keep(pattern, "VProj1217_403", grs_op_VProj, mode_F, 9, n_VProj1217);
+       ext_grs_node_t *n_VProj1137_404 = ext_grs_act_add_node_to_keep(pattern, "VProj1137_404", grs_op_VProj, mode_F, 10, n_VProj1137);
+       ext_grs_node_t *n_VProj1185_405 = ext_grs_act_add_node_to_keep(pattern, "VProj1185_405", grs_op_VProj, mode_F, 11, n_VProj1185);
+       ext_grs_node_t *n_VProj1161_406 = ext_grs_act_add_node_to_keep(pattern, "VProj1161_406", grs_op_VProj, mode_F, 12, n_VProj1161);
+       ext_grs_node_t *n_VProj1145_407 = ext_grs_act_add_node_to_keep(pattern, "VProj1145_407", grs_op_VProj, mode_F, 14, n_VProj1145);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 19);
+       ext_grs_node_t *n_VProj21_408 = ext_grs_act_add_node_to_keep(pattern, "VProj21_408", grs_op_VProj, mode_F, 20, n_Vector_Result1_Mul1170);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_30_409 = ext_grs_act_add_edge_to_keep(pattern, "pos1_30_409", 0, n_Arg_1_395, n_VProj1145_407, 1, e_pos1_30);
+       ext_grs_edge_t *e_pos0_15_410 = ext_grs_act_add_edge_to_keep(pattern, "pos0_15_410", -1, n_Vector_op_Block_397, n_VProj15_399, 2, e_pos0_15);
+       ext_grs_edge_t *e_pos0_31_411 = ext_grs_act_add_edge_to_keep(pattern, "pos0_31_411", -1, n_Vector_op_Block_397, n_VProj21_408, 3, e_pos0_31);
+       ext_grs_edge_t *e_pos0_36_412 = ext_grs_act_add_edge(pattern, "pos0_36_412", -1, n_Vector_op_Block_397, n_Vector_op_ProjData, 20);
+       ext_grs_edge_t *e_pos0_35_413 = ext_grs_act_add_edge(pattern, "pos0_35_413", -1, n_Vector_op_Block_397, n_Vector_op, 21);
+       ext_grs_edge_t *e_pos1_38_414 = ext_grs_act_add_edge(pattern, "pos1_38_414", 0, n_Arg_0_394, n_Vector_op, 22);
+       ext_grs_edge_t *e_pos1_37_415 = ext_grs_act_add_edge(pattern, "pos1_37_415", 0, n_Vector_op, n_Vector_op_ProjData, 23);
+       ext_grs_edge_t *e_pos1_34_416 = ext_grs_act_add_edge_to_keep(pattern, "pos1_34_416", 0, n_Arg_0_394, n_VProj1161_406, 5, e_pos1_34);
+       ext_grs_edge_t *e_pos2_39_417 = ext_grs_act_add_edge(pattern, "pos2_39_417", 1, n_Arg_1_395, n_Vector_op, 24);
+       ext_grs_edge_t *e_pos0_18_418 = ext_grs_act_add_edge_to_keep(pattern, "pos0_18_418", -1, n_Vector_op_Block_397, n_VProj17_396, 9, e_pos0_18);
+       ext_grs_edge_t *e_pos1_40_419 = ext_grs_act_add_edge(pattern, "pos1_40_419", 0, n_Vector_op_ProjData, n_VProj15_399, 25);
+       ext_grs_edge_t *e_pos1_41_420 = ext_grs_act_add_edge(pattern, "pos1_41_420", 0, n_Vector_op_ProjData, n_VProj17_396, 26);
+       ext_grs_edge_t *e_pos0_23_421 = ext_grs_act_add_edge_to_keep(pattern, "pos0_23_421", -1, n_Vector_op_Block_397, n_VProj19_401, 11, e_pos0_23);
+       ext_grs_edge_t *e_pos1_42_422 = ext_grs_act_add_edge(pattern, "pos1_42_422", 0, n_Vector_op_ProjData, n_VProj19_401, 27);
+       ext_grs_edge_t *e_pos1_21_423 = ext_grs_act_add_edge_to_keep(pattern, "pos1_21_423", 0, n_Arg_0_394, n_VProj1209_400, 14, e_pos1_21);
+       ext_grs_edge_t *e_pos1_22_424 = ext_grs_act_add_edge_to_keep(pattern, "pos1_22_424", 0, n_Arg_1_395, n_VProj1217_403, 15, e_pos1_22);
+       ext_grs_edge_t *e_pos1_43_425 = ext_grs_act_add_edge(pattern, "pos1_43_425", 0, n_Vector_op_ProjData, n_VProj21_408, 28);
+       ext_grs_edge_t *e_pos1_26_426 = ext_grs_act_add_edge_to_keep(pattern, "pos1_26_426", 0, n_Arg_1_395, n_VProj1169_402, 16, e_pos1_26);
+       ext_grs_edge_t *e_pos1_27_427 = ext_grs_act_add_edge_to_keep(pattern, "pos1_27_427", 0, n_Arg_0_394, n_VProj1137_404, 17, e_pos1_27);
+       ext_grs_edge_t *e_pos1_28_428 = ext_grs_act_add_edge_to_keep(pattern, "pos1_28_428", 0, n_Arg_0_394, n_VProj1185_405, 18, e_pos1_28);
+       ext_grs_edge_t *e_pos1_29_429 = ext_grs_act_add_edge_to_keep(pattern, "pos1_29_429", 0, n_Arg_1_395, n_VProj1193_398, 19, e_pos1_29);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36846);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36849);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36852);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36855);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36858);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* mulps_4_32_variant0 */
+
+
+/* functions for evaluation of conditions of action psadbw_variant0 */
+static int grs_cond_func_42812(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[171/* Proj2399 */]) == 0;
+}
+static int grs_cond_func_42815(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[66/* VProj3426 */]) == 12;
+}
+static int grs_cond_func_42818(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[447/* e299 */]) == get_edge_src_pos(edge_map[308/* e681 */]);
+}
+static int grs_cond_func_42821(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[84/* e300 */]) == get_edge_src_pos(edge_map[313/* e682 */]);
+}
+static int grs_cond_func_42824(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[81/* e304 */]) == get_edge_src_pos(edge_map[23/* e631 */]);
+}
+static int grs_cond_func_42827(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[78/* e305 */]) == get_edge_src_pos(edge_map[25/* e632 */]);
+}
+static int grs_cond_func_42830(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[230/* Proj2482 */]) == 4;
+}
+static int grs_cond_func_42833(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[30/* e321 */]) == get_edge_src_pos(edge_map[211/* e584 */]);
+}
+static int grs_cond_func_42836(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[32/* e322 */]) == get_edge_src_pos(edge_map[208/* e585 */]);
+}
+static int grs_cond_func_42839(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[213/* VProj3165 */]) == 9;
+}
+static int grs_cond_func_42842(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[240/* VProj2556 */]) == 2;
+}
+static int grs_cond_func_42845(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[225/* VProj3078 */]) == 8;
+}
+static int grs_cond_func_42848(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[81/* VProj3600 */]) == 14;
+}
+static int grs_cond_func_42851(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[212/* VProj3001 */]) == 7;
+}
+static int grs_cond_func_42854(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[94/* VProj2740 */]) == 4;
+}
+static int grs_cond_func_42857(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[59/* Proj2830 */]) == 4;
+}
+static int grs_cond_func_42860(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[236/* Proj2485 */]) == 1;
+}
+static int grs_cond_func_42863(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[107/* Proj3094 */]) == 1;
+}
+static int grs_cond_func_42866(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[237/* Proj3007 */]) == 1;
+}
+static int grs_cond_func_42869(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[270/* Proj3529 */]) == 1;
+}
+static int grs_cond_func_42872(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[280/* Proj2745 */]) == 0;
+}
+static int grs_cond_func_42875(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[35/* VProj3513 */]) == 13;
+}
+static int grs_cond_func_42878(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[30/* Proj3180 */]) == 0;
+}
+static int grs_cond_func_42881(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[262/* VProj3252 */]) == 10;
+}
+static int grs_cond_func_42884(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[57/* VProj2479 */]) == 1;
+}
+static int grs_cond_func_42887(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[252/* Proj2569 */]) == 4;
+}
+static int grs_cond_func_42890(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[0/* Proj3178 */]) == 4;
+}
+static int grs_cond_func_42893(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[28/* Proj3442 */]) == 1;
+}
+static int grs_cond_func_42896(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[110/* Proj3091 */]) == 4;
+}
+static int grs_cond_func_42899(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[259/* Proj3613 */]) == 4;
+}
+static int grs_cond_func_42902(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[32/* VProj2643 */]) == 3;
+}
+static int grs_cond_func_42905(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[254/* VProj2817 */]) == 5;
+}
+static int grs_cond_func_42908(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[277/* VProj2827 */]) == 5;
+}
+static int grs_cond_func_42911(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[31/* Proj3181 */]) == 1;
+}
+static int grs_cond_func_42914(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[234/* Proj2572 */]) == 1;
+}
+static int grs_cond_func_42917(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[265/* Proj3616 */]) == 1;
+}
+static int grs_cond_func_42920(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[271/* Proj3528 */]) == 0;
+}
+static int grs_cond_func_42923(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[49/* e453 */]) == get_edge_src_pos(edge_map[17/* e420 */]);
+}
+static int grs_cond_func_42926(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[50/* e454 */]) == get_edge_src_pos(edge_map[20/* e421 */]);
+}
+static int grs_cond_func_42929(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[123/* e460 */]) == get_edge_src_pos(edge_map[0/* e624 */]);
+}
+static int grs_cond_func_42932(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[122/* e461 */]) == get_edge_src_pos(edge_map[2/* e625 */]);
+}
+static int grs_cond_func_42935(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[119/* e464 */]) == get_edge_src_pos(edge_map[132/* e351 */]);
+}
+static int grs_cond_func_42938(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[118/* e465 */]) == get_edge_src_pos(edge_map[130/* e352 */]);
+}
+static int grs_cond_func_42941(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[98/* Proj2919 */]) == 0;
+}
+static int grs_cond_func_42944(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[116/* VProj3436 */]) == 12;
+}
+static int grs_cond_func_42947(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[276/* Proj3526 */]) == 4;
+}
+static int grs_cond_func_42950(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[101/* e478 */]) == get_edge_src_pos(edge_map[45/* e312 */]);
+}
+static int grs_cond_func_42953(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[104/* e479 */]) == get_edge_src_pos(edge_map[48/* e313 */]);
+}
+static int grs_cond_func_42956(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[149/* e489 */]) == get_edge_src_pos(edge_map[5/* e523 */]);
+}
+static int grs_cond_func_42959(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[157/* e490 */]) == get_edge_src_pos(edge_map[6/* e524 */]);
+}
+static int grs_cond_func_42962(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[135/* e492 */]) == get_edge_src_pos(edge_map[87/* e715 */]);
+}
+static int grs_cond_func_42965(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[140/* e493 */]) == get_edge_src_pos(edge_map[85/* e716 */]);
+}
+static int grs_cond_func_42968(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[49/* VProj3339 */]) == 11;
+}
+static int grs_cond_func_42971(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[50/* VProj2566 */]) == 2;
+}
+static int grs_cond_func_42974(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[222/* VProj3175 */]) == 9;
+}
+static int grs_cond_func_42977(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[214/* Proj3354 */]) == 0;
+}
+static int grs_cond_func_42980(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[178/* Proj3265 */]) == 4;
+}
+static int grs_cond_func_42983(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[191/* Proj2656 */]) == 4;
+}
+static int grs_cond_func_42986(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[242/* VProj3088 */]) == 8;
+}
+static int grs_cond_func_42989(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[42/* VProj3610 */]) == 14;
+}
+static int grs_cond_func_42992(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[181/* Proj3268 */]) == 1;
+}
+static int grs_cond_func_42995(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[43/* Proj3700 */]) == 4;
+}
+static int grs_cond_func_42998(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[245/* VProj3687 */]) == 15;
+}
+static int grs_cond_func_43001(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[153/* VProj2904 */]) == 6;
+}
+static int grs_cond_func_43004(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[170/* Proj2397 */]) == 4;
+}
+static int grs_cond_func_43007(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[192/* Proj2658 */]) == 0;
+}
+static int grs_cond_func_43010(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[193/* Proj2659 */]) == 1;
+}
+static int grs_cond_func_43013(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[347/* e556 */]) == get_edge_src_pos(edge_map[340/* e403 */]);
+}
+static int grs_cond_func_43016(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[345/* e557 */]) == get_edge_src_pos(edge_map[344/* e404 */]);
+}
+static int grs_cond_func_43019(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[60/* Proj2833 */]) == 1;
+}
+static int grs_cond_func_43022(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[286/* e573 */]) == get_edge_src_pos(edge_map[8/* e433 */]);
+}
+static int grs_cond_func_43025(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[290/* e574 */]) == get_edge_src_pos(edge_map[10/* e434 */]);
+}
+static int grs_cond_func_43028(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[39/* Proj3702 */]) == 0;
+}
+static int grs_cond_func_43031(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[51/* VProj3523 */]) == 13;
+}
+static int grs_cond_func_43034(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[106/* Proj3093 */]) == 0;
+}
+static int grs_cond_func_43037(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[215/* Proj3352 */]) == 4;
+}
+static int grs_cond_func_43040(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[238/* Proj2484 */]) == 0;
+}
+static int grs_cond_func_43043(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[287/* VProj3262 */]) == 10;
+}
+static int grs_cond_func_43046(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[6/* VProj2385 */]) == 0;
+}
+static int grs_cond_func_43049(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[17/* VProj2653 */]) == 3;
+}
+static int grs_cond_func_43052(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[195/* VProj3697 */]) == 15;
+}
+static int grs_cond_func_43055(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[209/* Proj3355 */]) == 1;
+}
+static int grs_cond_func_43058(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[101/* Proj2917 */]) == 4;
+}
+static int grs_cond_func_43061(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[21/* VProj2394 */]) == 0;
+}
+static int grs_cond_func_43064(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[112/* VProj2730 */]) == 4;
+}
+static int grs_cond_func_43067(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[27/* Proj3441 */]) == 0;
+}
+static int grs_cond_func_43070(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[38/* Proj3703 */]) == 1;
+}
+static int grs_cond_func_43073(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[105/* Proj2920 */]) == 1;
+}
+static int grs_cond_func_43076(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[56/* Proj2832 */]) == 0;
+}
+static int grs_cond_func_43079(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[33/* VProj3349 */]) == 11;
+}
+static int grs_cond_func_43082(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[13/* Proj3439 */]) == 4;
+}
+static int grs_cond_func_43085(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[179/* Proj3267 */]) == 0;
+}
+static int grs_cond_func_43088(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[319/* e688 */]) == get_edge_src_pos(edge_map[28/* e427 */]);
+}
+static int grs_cond_func_43091(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[317/* e689 */]) == get_edge_src_pos(edge_map[26/* e428 */]);
+}
+static int grs_cond_func_43094(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[339/* e692 */]) == get_edge_src_pos(edge_map[144/* e497 */]);
+}
+static int grs_cond_func_43097(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[343/* e693 */]) == get_edge_src_pos(edge_map[143/* e498 */]);
+}
+static int grs_cond_func_43100(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[44/* VProj2469 */]) == 1;
+}
+static int grs_cond_func_43103(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[69/* e700 */]) == get_edge_src_pos(edge_map[155/* e617 */]);
+}
+static int grs_cond_func_43106(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[66/* e701 */]) == get_edge_src_pos(edge_map[156/* e618 */]);
+}
+static int grs_cond_func_43109(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[10/* VProj2991 */]) == 7;
+}
+static int grs_cond_func_43112(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[57/* e705 */]) == get_edge_src_pos(edge_map[18/* e325 */]);
+}
+static int grs_cond_func_43115(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[59/* e706 */]) == get_edge_src_pos(edge_map[21/* e326 */]);
+}
+static int grs_cond_func_43118(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[257/* VProj2914 */]) == 6;
+}
+static int grs_cond_func_43121(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[90/* e711 */]) == get_edge_src_pos(edge_map[352/* e552 */]);
+}
+static int grs_cond_func_43124(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_edge_src_pos(edge_map[89/* e712 */]) == get_edge_src_pos(edge_map[350/* e553 */]);
+}
+static int grs_cond_func_43127(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[227/* Proj3004 */]) == 4;
+}
+static int grs_cond_func_43130(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[283/* Proj2743 */]) == 4;
+}
+static int grs_cond_func_43133(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[65/* Proj2400 */]) == 1;
+}
+static int grs_cond_func_43136(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[231/* Proj2571 */]) == 0;
+}
+static int grs_cond_func_43139(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[263/* Proj3615 */]) == 0;
+}
+static int grs_cond_func_43142(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[282/* Proj2746 */]) == 1;
+}
+static int grs_cond_func_43145(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[232/* Proj3006 */]) == 0;
+}
+
+static void *grs_eval_out_func_44235(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[290/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_44238(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[292/* VProj290 */], 0);
+  return(NULL);
+}
+/* functions for building the pattern of action psadbw_variant0 */
+static _inline ext_grs_action_t *grs_action_psadbw_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "psadbw_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Proj3178 = ext_grs_act_add_node(pattern, "Proj3178", grs_op_Proj, mode_b, 0);
+    ext_grs_node_t *n_Sub3234 = ext_grs_act_add_node(pattern, "Sub3234", grs_op_Sub, mode_Is, 1);
+    ext_grs_node_t *n_Sub3556 = ext_grs_act_add_node(pattern, "Sub3556", grs_op_Sub, mode_Is, 2);
+    ext_grs_node_t *n_Phi3620 = ext_grs_act_add_node(pattern, "Phi3620", grs_op_Phi, mode_Is, 3);
+    ext_grs_node_t *n_Block3329 = ext_grs_act_add_node(pattern, "Block3329", grs_op_Block, mode_BB, 4);
+    ext_grs_node_t *n_Sub2886 = ext_grs_act_add_node(pattern, "Sub2886", grs_op_Sub, mode_Is, 5);
+    ext_grs_node_t *n_VProj2385 = ext_grs_act_add_node(pattern, "VProj2385", grs_op_VProj, mode_Bu, 6);
+    ext_grs_node_t *n_Conv2818 = ext_grs_act_add_node(pattern, "Conv2818", grs_op_Conv, mode_Is, 7);
+    ext_grs_node_t *n_Block3328 = ext_grs_act_add_node(pattern, "Block3328", grs_op_Block, mode_BB, 8);
+    ext_grs_node_t *n_Conv2915 = ext_grs_act_add_node(pattern, "Conv2915", grs_op_Conv, mode_Is, 9);
+    ext_grs_node_t *n_VProj2991 = ext_grs_act_add_node(pattern, "VProj2991", grs_op_VProj, mode_Bu, 10);
+    ext_grs_node_t *n_Cond3527 = ext_grs_act_add_node(pattern, "Cond3527", grs_op_Cond, mode_T, 11);
+    ext_grs_node_t *n_Jmp2948 = ext_grs_act_add_node(pattern, "Jmp2948", grs_op_Jmp, mode_X, 12);
+    ext_grs_node_t *n_Proj3439 = ext_grs_act_add_node(pattern, "Proj3439", grs_op_Proj, mode_b, 13);
+    ext_grs_node_t *n_Sub3034 = ext_grs_act_add_node(pattern, "Sub3034", grs_op_Sub, mode_Is, 14);
+    ext_grs_node_t *n_Sub2686 = ext_grs_act_add_node(pattern, "Sub2686", grs_op_Sub, mode_Is, 15);
+    ext_grs_node_t *n_Sub3756 = ext_grs_act_add_node(pattern, "Sub3756", grs_op_Sub, mode_Is, 16);
+    ext_grs_node_t *n_VProj2653 = ext_grs_act_add_node(pattern, "VProj2653", grs_op_VProj, mode_Bu, 17);
+    ext_grs_node_t *n_Jmp3061 = ext_grs_act_add_node(pattern, "Jmp3061", grs_op_Jmp, mode_X, 18);
+    ext_grs_node_t *n_Conv2828 = ext_grs_act_add_node(pattern, "Conv2828", grs_op_Conv, mode_Is, 19);
+    ext_grs_node_t *n_Jmp2539 = ext_grs_act_add_node(pattern, "Jmp2539", grs_op_Jmp, mode_X, 20);
+    ext_grs_node_t *n_VProj2394 = ext_grs_act_add_node(pattern, "VProj2394", grs_op_VProj, mode_Bu, 21);
+    ext_grs_node_t *n_Sub3321 = ext_grs_act_add_node(pattern, "Sub3321", grs_op_Sub, mode_Is, 22);
+    ext_grs_node_t *n_Sub3643 = ext_grs_act_add_node(pattern, "Sub3643", grs_op_Sub, mode_Is, 23);
+    ext_grs_node_t *n_Conv3089 = ext_grs_act_add_node(pattern, "Conv3089", grs_op_Conv, mode_Is, 24);
+    ext_grs_node_t *n_Sub3121 = ext_grs_act_add_node(pattern, "Sub3121", grs_op_Sub, mode_Is, 25);
+    ext_grs_node_t *n_Phi3707 = ext_grs_act_add_node(pattern, "Phi3707", grs_op_Phi, mode_Is, 26);
+    ext_grs_node_t *n_Proj3441 = ext_grs_act_add_node(pattern, "Proj3441", grs_op_Proj, mode_X, 27);
+    ext_grs_node_t *n_Proj3442 = ext_grs_act_add_node(pattern, "Proj3442", grs_op_Proj, mode_X, 28);
+    ext_grs_node_t *n_Cond3440 = ext_grs_act_add_node(pattern, "Cond3440", grs_op_Cond, mode_T, 29);
+    ext_grs_node_t *n_Proj3180 = ext_grs_act_add_node(pattern, "Proj3180", grs_op_Proj, mode_X, 30);
+    ext_grs_node_t *n_Proj3181 = ext_grs_act_add_node(pattern, "Proj3181", grs_op_Proj, mode_X, 31);
+    ext_grs_node_t *n_VProj2643 = ext_grs_act_add_node(pattern, "VProj2643", grs_op_VProj, mode_Bu, 32);
+    ext_grs_node_t *n_VProj3349 = ext_grs_act_add_node(pattern, "VProj3349", grs_op_VProj, mode_Bu, 33);
+    ext_grs_node_t *n_Jmp2626 = ext_grs_act_add_node(pattern, "Jmp2626", grs_op_Jmp, mode_X, 34);
+    ext_grs_node_t *n_VProj3513 = ext_grs_act_add_node(pattern, "VProj3513", grs_op_VProj, mode_Bu, 35);
+    ext_grs_node_t *n_Jmp3322 = ext_grs_act_add_node(pattern, "Jmp3322", grs_op_Jmp, mode_X, 36);
+    ext_grs_node_t *n_Phi2489 = ext_grs_act_add_node(pattern, "Phi2489", grs_op_Phi, mode_Is, 37);
+    ext_grs_node_t *n_Proj3703 = ext_grs_act_add_node(pattern, "Proj3703", grs_op_Proj, mode_X, 38);
+    ext_grs_node_t *n_Proj3702 = ext_grs_act_add_node(pattern, "Proj3702", grs_op_Proj, mode_X, 39);
+    ext_grs_node_t *n_Jmp2427 = ext_grs_act_add_node(pattern, "Jmp2427", grs_op_Jmp, mode_X, 40);
+    ext_grs_node_t *n_Block3099 = ext_grs_act_add_node(pattern, "Block3099", grs_op_Block, mode_BB, 41);
+    ext_grs_node_t *n_VProj3610 = ext_grs_act_add_node(pattern, "VProj3610", grs_op_VProj, mode_Bu, 42);
+    ext_grs_node_t *n_Proj3700 = ext_grs_act_add_node(pattern, "Proj3700", grs_op_Proj, mode_b, 43);
+    ext_grs_node_t *n_VProj2469 = ext_grs_act_add_node(pattern, "VProj2469", grs_op_VProj, mode_Bu, 44);
+    ext_grs_node_t *n_Conv3688 = ext_grs_act_add_node(pattern, "Conv3688", grs_op_Conv, mode_Is, 45);
+    ext_grs_node_t *n_Add2544 = ext_grs_act_add_node(pattern, "Add2544", grs_op_Add, mode_Is, 46);
+    ext_grs_node_t *n_Sub3730 = ext_grs_act_add_node(pattern, "Sub3730", grs_op_Sub, mode_Is, 47);
+    ext_grs_node_t *n_Jmp3035 = ext_grs_act_add_node(pattern, "Jmp3035", grs_op_Jmp, mode_X, 48);
+    ext_grs_node_t *n_VProj3339 = ext_grs_act_add_node(pattern, "VProj3339", grs_op_VProj, mode_Bu, 49);
+    ext_grs_node_t *n_VProj2566 = ext_grs_act_add_node(pattern, "VProj2566", grs_op_VProj, mode_Bu, 50);
+    ext_grs_node_t *n_VProj3523 = ext_grs_act_add_node(pattern, "VProj3523", grs_op_VProj, mode_Bu, 51);
+    ext_grs_node_t *n_Phi3870 = ext_grs_act_add_node(pattern, "Phi3870", grs_op_Phi, mode_Is, 52);
+    ext_grs_node_t *n_Conv3698 = ext_grs_act_add_node(pattern, "Conv3698", grs_op_Conv, mode_Is, 53);
+    ext_grs_node_t *n_Sub3208 = ext_grs_act_add_node(pattern, "Sub3208", grs_op_Sub, mode_Is, 54);
+    ext_grs_node_t *n_Sub3669 = ext_grs_act_add_node(pattern, "Sub3669", grs_op_Sub, mode_Is, 55);
+    ext_grs_node_t *n_Proj2832 = ext_grs_act_add_node(pattern, "Proj2832", grs_op_Proj, mode_X, 56);
+    ext_grs_node_t *n_VProj2479 = ext_grs_act_add_node(pattern, "VProj2479", grs_op_VProj, mode_Bu, 57);
+    ext_grs_node_t *n_Sub2799 = ext_grs_act_add_node(pattern, "Sub2799", grs_op_Sub, mode_Is, 58);
+    ext_grs_node_t *n_Proj2830 = ext_grs_act_add_node(pattern, "Proj2830", grs_op_Proj, mode_b, 59);
+    ext_grs_node_t *n_Proj2833 = ext_grs_act_add_node(pattern, "Proj2833", grs_op_Proj, mode_X, 60);
+    ext_grs_node_t *n_Block3677 = ext_grs_act_add_node(pattern, "Block3677", grs_op_Block, mode_BB, 61);
+    ext_grs_node_t *n_Sub3147 = ext_grs_act_add_node(pattern, "Sub3147", grs_op_Sub, mode_Is, 62);
+    ext_grs_node_t *n_Block3676 = ext_grs_act_add_node(pattern, "Block3676", grs_op_Block, mode_BB, 63);
+    ext_grs_node_t *n_Phi2750 = ext_grs_act_add_node(pattern, "Phi2750", grs_op_Phi, mode_Is, 64);
+    ext_grs_node_t *n_Proj2400 = ext_grs_act_add_node(pattern, "Proj2400", grs_op_Proj, mode_X, 65);
+    ext_grs_node_t *n_VProj3426 = ext_grs_act_add_node(pattern, "VProj3426", grs_op_VProj, mode_Bu, 66);
+    ext_grs_node_t *n_Phi3098 = ext_grs_act_add_node(pattern, "Phi3098", grs_op_Phi, mode_Is, 67);
+    ext_grs_node_t *n_Jmp2600 = ext_grs_act_add_node(pattern, "Jmp2600", grs_op_Jmp, mode_X, 68);
+    ext_grs_node_t *n_Jmp3409 = ext_grs_act_add_node(pattern, "Jmp3409", grs_op_Jmp, mode_X, 69);
+    ext_grs_node_t *n_Jmp2887 = ext_grs_act_add_node(pattern, "Jmp2887", grs_op_Jmp, mode_X, 70);
+    ext_grs_node_t *n_Jmp3209 = ext_grs_act_add_node(pattern, "Jmp3209", grs_op_Jmp, mode_X, 71);
+    ext_grs_node_t *n_Conv3514 = ext_grs_act_add_node(pattern, "Conv3514", grs_op_Conv, mode_Is, 72);
+    ext_grs_node_t *n_Add2979 = ext_grs_act_add_node(pattern, "Add2979", grs_op_Add, mode_Is, 73);
+    ext_grs_node_t *n_Block3360 = ext_grs_act_add_node(pattern, "Block3360", grs_op_Block, mode_BB, 74);
+    ext_grs_node_t *n_Cond2570 = ext_grs_act_add_node(pattern, "Cond2570", grs_op_Cond, mode_T, 75);
+    ext_grs_node_t *n_Block3067 = ext_grs_act_add_node(pattern, "Block3067", grs_op_Block, mode_BB, 76);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 77);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 78);
+    ext_grs_node_t *n_Block3068 = ext_grs_act_add_node(pattern, "Block3068", grs_op_Block, mode_BB, 79);
+    ext_grs_node_t *n_Add3588 = ext_grs_act_add_node(pattern, "Add3588", grs_op_Add, mode_Is, 80);
+    ext_grs_node_t *n_VProj3600 = ext_grs_act_add_node(pattern, "VProj3600", grs_op_VProj, mode_Bu, 81);
+    ext_grs_node_t *n_Conv2644 = ext_grs_act_add_node(pattern, "Conv2644", grs_op_Conv, mode_Is, 82);
+    ext_grs_node_t *n_Cond2831 = ext_grs_act_add_node(pattern, "Cond2831", grs_op_Cond, mode_T, 83);
+    ext_grs_node_t *n_Cond3179 = ext_grs_act_add_node(pattern, "Cond3179", grs_op_Cond, mode_T, 84);
+    ext_grs_node_t *n_Conv3253 = ext_grs_act_add_node(pattern, "Conv3253", grs_op_Conv, mode_Is, 85);
+    ext_grs_node_t *n_Block2894 = ext_grs_act_add_node(pattern, "Block2894", grs_op_Block, mode_BB, 86);
+    ext_grs_node_t *n_Block3273 = ext_grs_act_add_node(pattern, "Block3273", grs_op_Block, mode_BB, 87);
+    ext_grs_node_t *n_Block2893 = ext_grs_act_add_node(pattern, "Block2893", grs_op_Block, mode_BB, 88);
+    ext_grs_node_t *n_Jmp3731 = ext_grs_act_add_node(pattern, "Jmp3731", grs_op_Jmp, mode_X, 89);
+    ext_grs_node_t *n_Block2751 = ext_grs_act_add_node(pattern, "Block2751", grs_op_Block, mode_BB, 90);
+    ext_grs_node_t *n_Block2490 = ext_grs_act_add_node(pattern, "Block2490", grs_op_Block, mode_BB, 91);
+    ext_grs_node_t *n_Sub2773 = ext_grs_act_add_node(pattern, "Sub2773", grs_op_Sub, mode_Is, 92);
+    ext_grs_node_t *n_Jmp2974 = ext_grs_act_add_node(pattern, "Jmp2974", grs_op_Jmp, mode_X, 93);
+    ext_grs_node_t *n_VProj2740 = ext_grs_act_add_node(pattern, "VProj2740", grs_op_VProj, mode_Bu, 94);
+    ext_grs_node_t *n_Conv2654 = ext_grs_act_add_node(pattern, "Conv2654", grs_op_Conv, mode_Is, 95);
+    ext_grs_node_t *n_Phi2924 = ext_grs_act_add_node(pattern, "Phi2924", grs_op_Phi, mode_Is, 96);
+    ext_grs_node_t *n_Phi2837 = ext_grs_act_add_node(pattern, "Phi2837", grs_op_Phi, mode_Is, 97);
+    ext_grs_node_t *n_Proj2919 = ext_grs_act_add_node(pattern, "Proj2919", grs_op_Proj, mode_X, 98);
+    ext_grs_node_t *n_Block3241 = ext_grs_act_add_node(pattern, "Block3241", grs_op_Block, mode_BB, 99);
+    ext_grs_node_t *n_Block3242 = ext_grs_act_add_node(pattern, "Block3242", grs_op_Block, mode_BB, 100);
+    ext_grs_node_t *n_Proj2917 = ext_grs_act_add_node(pattern, "Proj2917", grs_op_Proj, mode_b, 101);
+    ext_grs_node_t *n_Conv3263 = ext_grs_act_add_node(pattern, "Conv3263", grs_op_Conv, mode_Is, 102);
+    ext_grs_node_t *n_Block3621 = ext_grs_act_add_node(pattern, "Block3621", grs_op_Block, mode_BB, 103);
+    ext_grs_node_t *n_Add3066 = ext_grs_act_add_node(pattern, "Add3066", grs_op_Add, mode_Is, 104);
+    ext_grs_node_t *n_Proj2920 = ext_grs_act_add_node(pattern, "Proj2920", grs_op_Proj, mode_X, 105);
+    ext_grs_node_t *n_Proj3093 = ext_grs_act_add_node(pattern, "Proj3093", grs_op_Proj, mode_X, 106);
+    ext_grs_node_t *n_Proj3094 = ext_grs_act_add_node(pattern, "Proj3094", grs_op_Proj, mode_X, 107);
+    ext_grs_node_t *n_Jmp2861 = ext_grs_act_add_node(pattern, "Jmp2861", grs_op_Jmp, mode_X, 108);
+    ext_grs_node_t *n_Block3447 = ext_grs_act_add_node(pattern, "Block3447", grs_op_Block, mode_BB, 109);
+    ext_grs_node_t *n_Proj3091 = ext_grs_act_add_node(pattern, "Proj3091", grs_op_Proj, mode_b, 110);
+    ext_grs_node_t *n_Block3589 = ext_grs_act_add_node(pattern, "Block3589", grs_op_Block, mode_BB, 111);
+    ext_grs_node_t *n_VProj2730 = ext_grs_act_add_node(pattern, "VProj2730", grs_op_VProj, mode_Bu, 112);
+    ext_grs_node_t *n_Cond3266 = ext_grs_act_add_node(pattern, "Cond3266", grs_op_Cond, mode_T, 113);
+    ext_grs_node_t *n_Jmp2713 = ext_grs_act_add_node(pattern, "Jmp2713", grs_op_Jmp, mode_X, 114);
+    ext_grs_node_t *n_Sub3382 = ext_grs_act_add_node(pattern, "Sub3382", grs_op_Sub, mode_Is, 115);
+    ext_grs_node_t *n_VProj3436 = ext_grs_act_add_node(pattern, "VProj3436", grs_op_VProj, mode_Bu, 116);
+    ext_grs_node_t *n_Block3590 = ext_grs_act_add_node(pattern, "Block3590", grs_op_Block, mode_BB, 117);
+    ext_grs_node_t *n_Conv2905 = ext_grs_act_add_node(pattern, "Conv2905", grs_op_Conv, mode_Is, 118);
+    ext_grs_node_t *n_Conv2395 = ext_grs_act_add_node(pattern, "Conv2395", grs_op_Conv, mode_Is, 119);
+    ext_grs_node_t *n_Jmp3583 = ext_grs_act_add_node(pattern, "Jmp3583", grs_op_Jmp, mode_X, 120);
+    ext_grs_node_t *n_Block3186 = ext_grs_act_add_node(pattern, "Block3186", grs_op_Block, mode_BB, 121);
+    ext_grs_node_t *n_Block2376 = ext_grs_act_add_node(pattern, "Block2376", grs_op_Block, mode_BB, 122);
+    ext_grs_node_t *n_Block2377 = ext_grs_act_add_node(pattern, "Block2377", grs_op_Block, mode_BB, 123);
+    ext_grs_node_t *n_Add2892 = ext_grs_act_add_node(pattern, "Add2892", grs_op_Add, mode_Is, 124);
+    ext_grs_node_t *n_Jmp2453 = ext_grs_act_add_node(pattern, "Jmp2453", grs_op_Jmp, mode_X, 125);
+    ext_grs_node_t *n_Add3327 = ext_grs_act_add_node(pattern, "Add3327", grs_op_Add, mode_Is, 126);
+    ext_grs_node_t *n_Conv3350 = ext_grs_act_add_node(pattern, "Conv3350", grs_op_Conv, mode_Is, 127);
+    ext_grs_node_t *n_Sub2947 = ext_grs_act_add_node(pattern, "Sub2947", grs_op_Sub, mode_Is, 128);
+    ext_grs_node_t *n_Block2720 = ext_grs_act_add_node(pattern, "Block2720", grs_op_Block, mode_BB, 129);
+    ext_grs_node_t *n_Cond2483 = ext_grs_act_add_node(pattern, "Cond2483", grs_op_Cond, mode_T, 130);
+    ext_grs_node_t *n_Block3534 = ext_grs_act_add_node(pattern, "Block3534", grs_op_Block, mode_BB, 131);
+    ext_grs_node_t *n_Jmp3383 = ext_grs_act_add_node(pattern, "Jmp3383", grs_op_Jmp, mode_X, 132);
+    ext_grs_node_t *n_Cmp5646 = ext_grs_act_add_node(pattern, "Cmp5646", grs_op_Cmp, mode_T, 133);
+    ext_grs_node_t *n_Cmp5647 = ext_grs_act_add_node(pattern, "Cmp5647", grs_op_Cmp, mode_T, 134);
+    ext_grs_node_t *n_Cmp5648 = ext_grs_act_add_node(pattern, "Cmp5648", grs_op_Cmp, mode_T, 135);
+    ext_grs_node_t *n_Sub2512 = ext_grs_act_add_node(pattern, "Sub2512", grs_op_Sub, mode_Is, 136);
+    ext_grs_node_t *n_Cmp5649 = ext_grs_act_add_node(pattern, "Cmp5649", grs_op_Cmp, mode_T, 137);
+    ext_grs_node_t *n_Block2458 = ext_grs_act_add_node(pattern, "Block2458", grs_op_Block, mode_BB, 138);
+    ext_grs_node_t *n_Cmp5645 = ext_grs_act_add_node(pattern, "Cmp5645", grs_op_Cmp, mode_T, 139);
+    ext_grs_node_t *n_Phi3185 = ext_grs_act_add_node(pattern, "Phi3185", grs_op_Phi, mode_Is, 140);
+    ext_grs_node_t *n_Block2925 = ext_grs_act_add_node(pattern, "Block2925", grs_op_Block, mode_BB, 141);
+    ext_grs_node_t *n_Block2459 = ext_grs_act_add_node(pattern, "Block2459", grs_op_Block, mode_BB, 142);
+    ext_grs_node_t *n_Block2719 = ext_grs_act_add_node(pattern, "Block2719", grs_op_Block, mode_BB, 143);
+    ext_grs_node_t *n_Add3240 = ext_grs_act_add_node(pattern, "Add3240", grs_op_Add, mode_Is, 144);
+    ext_grs_node_t *n_Phi2576 = ext_grs_act_add_node(pattern, "Phi2576", grs_op_Phi, mode_Is, 145);
+    ext_grs_node_t *n_Cond3092 = ext_grs_act_add_node(pattern, "Cond3092", grs_op_Cond, mode_T, 146);
+    ext_grs_node_t *n_Cond2657 = ext_grs_act_add_node(pattern, "Cond2657", grs_op_Cond, mode_T, 147);
+    ext_grs_node_t *n_Jmp3670 = ext_grs_act_add_node(pattern, "Jmp3670", grs_op_Jmp, mode_X, 148);
+    ext_grs_node_t *n_Conv2470 = ext_grs_act_add_node(pattern, "Conv2470", grs_op_Conv, mode_Is, 149);
+    ext_grs_node_t *n_Conv3340 = ext_grs_act_add_node(pattern, "Conv3340", grs_op_Conv, mode_Is, 150);
+    ext_grs_node_t *n_Block2664 = ext_grs_act_add_node(pattern, "Block2664", grs_op_Block, mode_BB, 151);
+    ext_grs_node_t *n_Conv3002 = ext_grs_act_add_node(pattern, "Conv3002", grs_op_Conv, mode_Is, 152);
+    ext_grs_node_t *n_VProj2904 = ext_grs_act_add_node(pattern, "VProj2904", grs_op_VProj, mode_Bu, 153);
+    ext_grs_node_t *n_Sub2426 = ext_grs_act_add_node(pattern, "Sub2426", grs_op_Sub, mode_Is, 154);
+    ext_grs_node_t *n_Cond2398 = ext_grs_act_add_node(pattern, "Cond2398", grs_op_Cond, mode_T, 155);
+    ext_grs_node_t *n_Cmp5659 = ext_grs_act_add_node(pattern, "Cmp5659", grs_op_Cmp, mode_T, 156);
+    ext_grs_node_t *n_Cmp5657 = ext_grs_act_add_node(pattern, "Cmp5657", grs_op_Cmp, mode_T, 157);
+    ext_grs_node_t *n_Cond2918 = ext_grs_act_add_node(pattern, "Cond2918", grs_op_Cond, mode_T, 158);
+    ext_grs_node_t *n_Cmp5658 = ext_grs_act_add_node(pattern, "Cmp5658", grs_op_Cmp, mode_T, 159);
+    ext_grs_node_t *n_Block3708 = ext_grs_act_add_node(pattern, "Block3708", grs_op_Block, mode_BB, 160);
+    ext_grs_node_t *n_Conv2480 = ext_grs_act_add_node(pattern, "Conv2480", grs_op_Conv, mode_Is, 161);
+    ext_grs_node_t *n_Cmp5656 = ext_grs_act_add_node(pattern, "Cmp5656", grs_op_Cmp, mode_T, 162);
+    ext_grs_node_t *n_Cmp5655 = ext_grs_act_add_node(pattern, "Cmp5655", grs_op_Cmp, mode_T, 163);
+    ext_grs_node_t *n_Cmp5654 = ext_grs_act_add_node(pattern, "Cmp5654", grs_op_Cmp, mode_T, 164);
+    ext_grs_node_t *n_Cmp5653 = ext_grs_act_add_node(pattern, "Cmp5653", grs_op_Cmp, mode_T, 165);
+    ext_grs_node_t *n_Cmp5652 = ext_grs_act_add_node(pattern, "Cmp5652", grs_op_Cmp, mode_T, 166);
+    ext_grs_node_t *n_Cmp5651 = ext_grs_act_add_node(pattern, "Cmp5651", grs_op_Cmp, mode_T, 167);
+    ext_grs_node_t *n_Cmp5650 = ext_grs_act_add_node(pattern, "Cmp5650", grs_op_Cmp, mode_T, 168);
+    ext_grs_node_t *n_Conv2386 = ext_grs_act_add_node(pattern, "Conv2386", grs_op_Conv, mode_Is, 169);
+    ext_grs_node_t *n_Proj2397 = ext_grs_act_add_node(pattern, "Proj2397", grs_op_Proj, mode_b, 170);
+    ext_grs_node_t *n_Proj2399 = ext_grs_act_add_node(pattern, "Proj2399", grs_op_Proj, mode_X, 171);
+    ext_grs_node_t *n_Phi2663 = ext_grs_act_add_node(pattern, "Phi2663", grs_op_Phi, mode_Is, 172);
+    ext_grs_node_t *n_Block3415 = ext_grs_act_add_node(pattern, "Block3415", grs_op_Block, mode_BB, 173);
+    ext_grs_node_t *n_Block3416 = ext_grs_act_add_node(pattern, "Block3416", grs_op_Block, mode_BB, 174);
+    ext_grs_node_t *n_Jmp3757 = ext_grs_act_add_node(pattern, "Jmp3757", grs_op_Jmp, mode_X, 175);
+    ext_grs_node_t *n_Block2632 = ext_grs_act_add_node(pattern, "Block2632", grs_op_Block, mode_BB, 176);
+    ext_grs_node_t *n_Phi3533 = ext_grs_act_add_node(pattern, "Phi3533", grs_op_Phi, mode_Is, 177);
+    ext_grs_node_t *n_Proj3265 = ext_grs_act_add_node(pattern, "Proj3265", grs_op_Proj, mode_b, 178);
+    ext_grs_node_t *n_Proj3267 = ext_grs_act_add_node(pattern, "Proj3267", grs_op_Proj, mode_X, 179);
+    ext_grs_node_t *n_Conv3601 = ext_grs_act_add_node(pattern, "Conv3601", grs_op_Conv, mode_Is, 180);
+    ext_grs_node_t *n_Proj3268 = ext_grs_act_add_node(pattern, "Proj3268", grs_op_Proj, mode_X, 181);
+    ext_grs_node_t *n_Cond3614 = ext_grs_act_add_node(pattern, "Cond3614", grs_op_Cond, mode_T, 182);
+    ext_grs_node_t *n_Jmp3122 = ext_grs_act_add_node(pattern, "Jmp3122", grs_op_Jmp, mode_X, 183);
+    ext_grs_node_t *n_Conv3437 = ext_grs_act_add_node(pattern, "Conv3437", grs_op_Conv, mode_Is, 184);
+    ext_grs_node_t *n_Sub2625 = ext_grs_act_add_node(pattern, "Sub2625", grs_op_Sub, mode_Is, 185);
+    ext_grs_node_t *n_Block2633 = ext_grs_act_add_node(pattern, "Block2633", grs_op_Block, mode_BB, 186);
+    ext_grs_node_t *n_Sub2538 = ext_grs_act_add_node(pattern, "Sub2538", grs_op_Sub, mode_Is, 187);
+    ext_grs_node_t *n_Block3155 = ext_grs_act_add_node(pattern, "Block3155", grs_op_Block, mode_BB, 188);
+    ext_grs_node_t *n_Block3154 = ext_grs_act_add_node(pattern, "Block3154", grs_op_Block, mode_BB, 189);
+    ext_grs_node_t *n_Sub3295 = ext_grs_act_add_node(pattern, "Sub3295", grs_op_Sub, mode_Is, 190);
+    ext_grs_node_t *n_Proj2656 = ext_grs_act_add_node(pattern, "Proj2656", grs_op_Proj, mode_b, 191);
+    ext_grs_node_t *n_Proj2658 = ext_grs_act_add_node(pattern, "Proj2658", grs_op_Proj, mode_X, 192);
+    ext_grs_node_t *n_Proj2659 = ext_grs_act_add_node(pattern, "Proj2659", grs_op_Proj, mode_X, 193);
+    ext_grs_node_t *n_Conv2557 = ext_grs_act_add_node(pattern, "Conv2557", grs_op_Conv, mode_Is, 194);
+    ext_grs_node_t *n_VProj3697 = ext_grs_act_add_node(pattern, "VProj3697", grs_op_VProj, mode_Bu, 195);
+    ext_grs_node_t *n_Jmp3557 = ext_grs_act_add_node(pattern, "Jmp3557", grs_op_Jmp, mode_X, 196);
+    ext_grs_node_t *n_Vector_Result0_Add3762 = ext_grs_act_add_node(pattern, "Vector_Result0_Add3762", grs_op_Add, mode_Is, 197);
+    ext_grs_node_t *n_Block3012 = ext_grs_act_add_node(pattern, "Block3012", grs_op_Block, mode_BB, 198);
+    ext_grs_node_t *n_Jmp3235 = ext_grs_act_add_node(pattern, "Jmp3235", grs_op_Jmp, mode_X, 199);
+    ext_grs_node_t *n_Sub2712 = ext_grs_act_add_node(pattern, "Sub2712", grs_op_Sub, mode_Is, 200);
+    ext_grs_node_t *n_Block2838 = ext_grs_act_add_node(pattern, "Block2838", grs_op_Block, mode_BB, 201);
+    ext_grs_node_t *n_Block2545 = ext_grs_act_add_node(pattern, "Block2545", grs_op_Block, mode_BB, 202);
+    ext_grs_node_t *n_Add3153 = ext_grs_act_add_node(pattern, "Add3153", grs_op_Add, mode_Is, 203);
+    ext_grs_node_t *n_Phi3359 = ext_grs_act_add_node(pattern, "Phi3359", grs_op_Phi, mode_Is, 204);
+    ext_grs_node_t *n_Block2546 = ext_grs_act_add_node(pattern, "Block2546", grs_op_Block, mode_BB, 205);
+    ext_grs_node_t *n_Conv3611 = ext_grs_act_add_node(pattern, "Conv3611", grs_op_Conv, mode_Is, 206);
+    ext_grs_node_t *n_Conv3524 = ext_grs_act_add_node(pattern, "Conv3524", grs_op_Conv, mode_Is, 207);
+    ext_grs_node_t *n_Conv3427 = ext_grs_act_add_node(pattern, "Conv3427", grs_op_Conv, mode_Is, 208);
+    ext_grs_node_t *n_Proj3355 = ext_grs_act_add_node(pattern, "Proj3355", grs_op_Proj, mode_X, 209);
+    ext_grs_node_t *n_Cond3353 = ext_grs_act_add_node(pattern, "Cond3353", grs_op_Cond, mode_T, 210);
+    ext_grs_node_t *n_Cond2744 = ext_grs_act_add_node(pattern, "Cond2744", grs_op_Cond, mode_T, 211);
+    ext_grs_node_t *n_VProj3001 = ext_grs_act_add_node(pattern, "VProj3001", grs_op_VProj, mode_Bu, 212);
+    ext_grs_node_t *n_VProj3165 = ext_grs_act_add_node(pattern, "VProj3165", grs_op_VProj, mode_Bu, 213);
+    ext_grs_node_t *n_Proj3354 = ext_grs_act_add_node(pattern, "Proj3354", grs_op_Proj, mode_X, 214);
+    ext_grs_node_t *n_Proj3352 = ext_grs_act_add_node(pattern, "Proj3352", grs_op_Proj, mode_b, 215);
+    ext_grs_node_t *n_Add3414 = ext_grs_act_add_node(pattern, "Add3414", grs_op_Add, mode_Is, 216);
+    ext_grs_node_t *n_Conv2567 = ext_grs_act_add_node(pattern, "Conv2567", grs_op_Conv, mode_Is, 217);
+    ext_grs_node_t *n_Sub3495 = ext_grs_act_add_node(pattern, "Sub3495", grs_op_Sub, mode_Is, 218);
+    ext_grs_node_t *n_Jmp3148 = ext_grs_act_add_node(pattern, "Jmp3148", grs_op_Jmp, mode_X, 219);
+    ext_grs_node_t *n_Jmp2800 = ext_grs_act_add_node(pattern, "Jmp2800", grs_op_Jmp, mode_X, 220);
+    ext_grs_node_t *n_Sub2599 = ext_grs_act_add_node(pattern, "Sub2599", grs_op_Sub, mode_Is, 221);
+    ext_grs_node_t *n_VProj3175 = ext_grs_act_add_node(pattern, "VProj3175", grs_op_VProj, mode_Bu, 222);
+    ext_grs_node_t *n_Sub3408 = ext_grs_act_add_node(pattern, "Sub3408", grs_op_Sub, mode_Is, 223);
+    ext_grs_node_t *n_Sub2452 = ext_grs_act_add_node(pattern, "Sub2452", grs_op_Sub, mode_Is, 224);
+    ext_grs_node_t *n_VProj3078 = ext_grs_act_add_node(pattern, "VProj3078", grs_op_VProj, mode_Bu, 225);
+    ext_grs_node_t *n_Conv2741 = ext_grs_act_add_node(pattern, "Conv2741", grs_op_Conv, mode_Is, 226);
+    ext_grs_node_t *n_Proj3004 = ext_grs_act_add_node(pattern, "Proj3004", grs_op_Proj, mode_b, 227);
+    ext_grs_node_t *n_Add3501 = ext_grs_act_add_node(pattern, "Add3501", grs_op_Add, mode_Is, 228);
+    ext_grs_node_t *n_Cond3005 = ext_grs_act_add_node(pattern, "Cond3005", grs_op_Cond, mode_T, 229);
+    ext_grs_node_t *n_Proj2482 = ext_grs_act_add_node(pattern, "Proj2482", grs_op_Proj, mode_b, 230);
+    ext_grs_node_t *n_Proj2571 = ext_grs_act_add_node(pattern, "Proj2571", grs_op_Proj, mode_X, 231);
+    ext_grs_node_t *n_Proj3006 = ext_grs_act_add_node(pattern, "Proj3006", grs_op_Proj, mode_X, 232);
+    ext_grs_node_t *n_Jmp2774 = ext_grs_act_add_node(pattern, "Jmp2774", grs_op_Jmp, mode_X, 233);
+    ext_grs_node_t *n_Proj2572 = ext_grs_act_add_node(pattern, "Proj2572", grs_op_Proj, mode_X, 234);
+    ext_grs_node_t *n_Sub3469 = ext_grs_act_add_node(pattern, "Sub3469", grs_op_Sub, mode_Is, 235);
+    ext_grs_node_t *n_Proj2485 = ext_grs_act_add_node(pattern, "Proj2485", grs_op_Proj, mode_X, 236);
+    ext_grs_node_t *n_Proj3007 = ext_grs_act_add_node(pattern, "Proj3007", grs_op_Proj, mode_X, 237);
+    ext_grs_node_t *n_Proj2484 = ext_grs_act_add_node(pattern, "Proj2484", grs_op_Proj, mode_X, 238);
+    ext_grs_node_t *n_Add3675 = ext_grs_act_add_node(pattern, "Add3675", grs_op_Add, mode_Is, 239);
+    ext_grs_node_t *n_VProj2556 = ext_grs_act_add_node(pattern, "VProj2556", grs_op_VProj, mode_Bu, 240);
+    ext_grs_node_t *n_Jmp3296 = ext_grs_act_add_node(pattern, "Jmp3296", grs_op_Jmp, mode_X, 241);
+    ext_grs_node_t *n_VProj3088 = ext_grs_act_add_node(pattern, "VProj3088", grs_op_VProj, mode_Bu, 242);
+    ext_grs_node_t *n_Add2631 = ext_grs_act_add_node(pattern, "Add2631", grs_op_Add, mode_Is, 243);
+    ext_grs_node_t *n_Phi3272 = ext_grs_act_add_node(pattern, "Phi3272", grs_op_Phi, mode_Is, 244);
+    ext_grs_node_t *n_VProj3687 = ext_grs_act_add_node(pattern, "VProj3687", grs_op_VProj, mode_Bu, 245);
+    ext_grs_node_t *n_Sub2973 = ext_grs_act_add_node(pattern, "Sub2973", grs_op_Sub, mode_Is, 246);
+    ext_grs_node_t *n_Conv2731 = ext_grs_act_add_node(pattern, "Conv2731", grs_op_Conv, mode_Is, 247);
+    ext_grs_node_t *n_Jmp2687 = ext_grs_act_add_node(pattern, "Jmp2687", grs_op_Jmp, mode_X, 248);
+    ext_grs_node_t *n_Block2806 = ext_grs_act_add_node(pattern, "Block2806", grs_op_Block, mode_BB, 249);
+    ext_grs_node_t *n_Block2807 = ext_grs_act_add_node(pattern, "Block2807", grs_op_Block, mode_BB, 250);
+    ext_grs_node_t *n_Jmp3496 = ext_grs_act_add_node(pattern, "Jmp3496", grs_op_Jmp, mode_X, 251);
+    ext_grs_node_t *n_Proj2569 = ext_grs_act_add_node(pattern, "Proj2569", grs_op_Proj, mode_b, 252);
+    ext_grs_node_t *n_Conv3176 = ext_grs_act_add_node(pattern, "Conv3176", grs_op_Conv, mode_Is, 253);
+    ext_grs_node_t *n_VProj2817 = ext_grs_act_add_node(pattern, "VProj2817", grs_op_VProj, mode_Bu, 254);
+    ext_grs_node_t *n_Block2577 = ext_grs_act_add_node(pattern, "Block2577", grs_op_Block, mode_BB, 255);
+    ext_grs_node_t *n_Conv3079 = ext_grs_act_add_node(pattern, "Conv3079", grs_op_Conv, mode_Is, 256);
+    ext_grs_node_t *n_VProj2914 = ext_grs_act_add_node(pattern, "VProj2914", grs_op_VProj, mode_Bu, 257);
+    ext_grs_node_t *n_Add2805 = ext_grs_act_add_node(pattern, "Add2805", grs_op_Add, mode_Is, 258);
+    ext_grs_node_t *n_Proj3613 = ext_grs_act_add_node(pattern, "Proj3613", grs_op_Proj, mode_b, 259);
+    ext_grs_node_t *n_Block2980 = ext_grs_act_add_node(pattern, "Block2980", grs_op_Block, mode_BB, 260);
+    ext_grs_node_t *n_Block2981 = ext_grs_act_add_node(pattern, "Block2981", grs_op_Block, mode_BB, 261);
+    ext_grs_node_t *n_VProj3252 = ext_grs_act_add_node(pattern, "VProj3252", grs_op_VProj, mode_Bu, 262);
+    ext_grs_node_t *n_Proj3615 = ext_grs_act_add_node(pattern, "Proj3615", grs_op_Proj, mode_X, 263);
+    ext_grs_node_t *n_Sub2860 = ext_grs_act_add_node(pattern, "Sub2860", grs_op_Sub, mode_Is, 264);
+    ext_grs_node_t *n_Proj3616 = ext_grs_act_add_node(pattern, "Proj3616", grs_op_Proj, mode_X, 265);
+    ext_grs_node_t *n_Jmp2513 = ext_grs_act_add_node(pattern, "Jmp2513", grs_op_Jmp, mode_X, 266);
+    ext_grs_node_t *n_Cmp5660 = ext_grs_act_add_node(pattern, "Cmp5660", grs_op_Cmp, mode_T, 267);
+    ext_grs_node_t *n_Sub3582 = ext_grs_act_add_node(pattern, "Sub3582", grs_op_Sub, mode_Is, 268);
+    ext_grs_node_t *n_Sub3060 = ext_grs_act_add_node(pattern, "Sub3060", grs_op_Sub, mode_Is, 269);
+    ext_grs_node_t *n_Proj3529 = ext_grs_act_add_node(pattern, "Proj3529", grs_op_Proj, mode_X, 270);
+    ext_grs_node_t *n_Proj3528 = ext_grs_act_add_node(pattern, "Proj3528", grs_op_Proj, mode_X, 271);
+    ext_grs_node_t *n_Add2718 = ext_grs_act_add_node(pattern, "Add2718", grs_op_Add, mode_Is, 272);
+    ext_grs_node_t *n_Phi3446 = ext_grs_act_add_node(pattern, "Phi3446", grs_op_Phi, mode_Is, 273);
+    ext_grs_node_t *n_Conv3166 = ext_grs_act_add_node(pattern, "Conv3166", grs_op_Conv, mode_Is, 274);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 275);
+    ext_grs_node_t *n_Proj3526 = ext_grs_act_add_node(pattern, "Proj3526", grs_op_Proj, mode_b, 276);
+    ext_grs_node_t *n_VProj2827 = ext_grs_act_add_node(pattern, "VProj2827", grs_op_VProj, mode_Bu, 277);
+    ext_grs_node_t *n_Block3503 = ext_grs_act_add_node(pattern, "Block3503", grs_op_Block, mode_BB, 278);
+    ext_grs_node_t *n_Block3502 = ext_grs_act_add_node(pattern, "Block3502", grs_op_Block, mode_BB, 279);
+    ext_grs_node_t *n_Proj2745 = ext_grs_act_add_node(pattern, "Proj2745", grs_op_Proj, mode_X, 280);
+    ext_grs_node_t *n_Jmp3470 = ext_grs_act_add_node(pattern, "Jmp3470", grs_op_Jmp, mode_X, 281);
+    ext_grs_node_t *n_Proj2746 = ext_grs_act_add_node(pattern, "Proj2746", grs_op_Proj, mode_X, 282);
+    ext_grs_node_t *n_Proj2743 = ext_grs_act_add_node(pattern, "Proj2743", grs_op_Proj, mode_b, 283);
+    ext_grs_node_t *n_Cond3701 = ext_grs_act_add_node(pattern, "Cond3701", grs_op_Cond, mode_T, 284);
+    ext_grs_node_t *n_Jmp3644 = ext_grs_act_add_node(pattern, "Jmp3644", grs_op_Jmp, mode_X, 285);
+    ext_grs_node_t *n_Conv2992 = ext_grs_act_add_node(pattern, "Conv2992", grs_op_Conv, mode_Is, 286);
+    ext_grs_node_t *n_VProj3262 = ext_grs_act_add_node(pattern, "VProj3262", grs_op_VProj, mode_Bu, 287);
+    ext_grs_node_t *n_Phi3011 = ext_grs_act_add_node(pattern, "Phi3011", grs_op_Phi, mode_Is, 288);
+    ext_grs_node_t *n_Block2404 = ext_grs_act_add_node(pattern, "Block2404", grs_op_Block, mode_BB, 289);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e624 = ext_grs_act_add_edge(pattern, "e624", ext_grs_NO_EDGE_POS, n_Jmp3035, n_Block3012, 0);
+    ext_grs_edge_t *e_e334 = ext_grs_act_add_edge(pattern, "e334", ext_grs_NO_EDGE_POS, n_Proj3180, n_Block3155, 1);
+    ext_grs_edge_t *e_e625 = ext_grs_act_add_edge(pattern, "e625", ext_grs_NO_EDGE_POS, n_Jmp3061, n_Block3012, 2);
+    ext_grs_edge_t *e_e430 = ext_grs_act_add_edge(pattern, "e430", ext_grs_NO_EDGE_POS, n_Phi3446, n_Add3414, 3);
+    ext_grs_edge_t *e_e431 = ext_grs_act_add_edge(pattern, "e431", ext_grs_NO_EDGE_POS, n_Add3327, n_Add3414, 4);
+    ext_grs_edge_t *e_e523 = ext_grs_act_add_edge(pattern, "e523", ext_grs_NO_EDGE_POS, n_Jmp2861, n_Block2838, 5);
+    ext_grs_edge_t *e_e524 = ext_grs_act_add_edge(pattern, "e524", ext_grs_NO_EDGE_POS, n_Jmp2887, n_Block2838, 6);
+    ext_grs_edge_t *e_pos2_621 = ext_grs_act_add_edge(pattern, "pos2_621", 1, n_Conv2470, n_Sub2538, 7);
+    ext_grs_edge_t *e_e433 = ext_grs_act_add_edge(pattern, "e433", ext_grs_NO_EDGE_POS, n_Jmp2513, n_Block2490, 8);
+    ext_grs_edge_t *e_e526 = ext_grs_act_add_edge(pattern, "e526", ext_grs_NO_EDGE_POS, n_Proj3702, n_Block3677, 9);
+    ext_grs_edge_t *e_e434 = ext_grs_act_add_edge(pattern, "e434", ext_grs_NO_EDGE_POS, n_Jmp2539, n_Block2490, 10);
+    ext_grs_edge_t *e_e331 = ext_grs_act_add_edge(pattern, "e331", ext_grs_NO_EDGE_POS, n_Phi3707, n_Add3675, 11);
+    ext_grs_edge_t *e_e332 = ext_grs_act_add_edge(pattern, "e332", ext_grs_NO_EDGE_POS, n_Add3588, n_Add3675, 12);
+    ext_grs_edge_t *e_pos0_324 = ext_grs_act_add_edge(pattern, "pos0_324", -1, n_Block3415, n_Jmp3470, 13);
+    ext_grs_edge_t *e_pos2_629 = ext_grs_act_add_edge(pattern, "pos2_629", 1, n_Conv3524, n_Sub3556, 14);
+    ext_grs_edge_t *e_pos2_385 = ext_grs_act_add_edge(pattern, "pos2_385", 1, n_Conv3437, n_Sub3469, 15);
+    ext_grs_edge_t *e_e637 = ext_grs_act_add_edge(pattern, "e637", ext_grs_NO_EDGE_POS, n_Phi2924, n_Add2892, 16);
+    ext_grs_edge_t *e_e420 = ext_grs_act_add_edge(pattern, "e420", ext_grs_NO_EDGE_POS, n_Jmp3731, n_Block3708, 17);
+    ext_grs_edge_t *e_e325 = ext_grs_act_add_edge(pattern, "e325", ext_grs_NO_EDGE_POS, n_Jmp2948, n_Block2925, 18);
+    ext_grs_edge_t *e_e638 = ext_grs_act_add_edge(pattern, "e638", ext_grs_NO_EDGE_POS, n_Add2805, n_Add2892, 19);
+    ext_grs_edge_t *e_e421 = ext_grs_act_add_edge(pattern, "e421", ext_grs_NO_EDGE_POS, n_Jmp3757, n_Block3708, 20);
+    ext_grs_edge_t *e_e326 = ext_grs_act_add_edge(pattern, "e326", ext_grs_NO_EDGE_POS, n_Jmp2974, n_Block2925, 21);
+    ext_grs_edge_t *e_pos2_470 = ext_grs_act_add_edge(pattern, "pos2_470", 1, n_Conv2395, n_Sub2426, 22);
+    ext_grs_edge_t *e_e631 = ext_grs_act_add_edge(pattern, "e631", ext_grs_NO_EDGE_POS, n_Jmp2427, n_Block2404, 23);
+    ext_grs_edge_t *e_pos2_576 = ext_grs_act_add_edge(pattern, "pos2_576", 1, n_Conv2395, n_Cmp5645, 24);
+    ext_grs_edge_t *e_e632 = ext_grs_act_add_edge(pattern, "e632", ext_grs_NO_EDGE_POS, n_Jmp2453, n_Block2404, 25);
+    ext_grs_edge_t *e_e428 = ext_grs_act_add_edge(pattern, "e428", ext_grs_NO_EDGE_POS, n_Jmp3148, n_Block3099, 26);
+    ext_grs_edge_t *e_e535 = ext_grs_act_add_edge(pattern, "e535", ext_grs_NO_EDGE_POS, n_Proj3093, n_Block3068, 27);
+    ext_grs_edge_t *e_e427 = ext_grs_act_add_edge(pattern, "e427", ext_grs_NO_EDGE_POS, n_Jmp3122, n_Block3099, 28);
+    ext_grs_edge_t *e_pos2_570 = ext_grs_act_add_edge(pattern, "pos2_570", 1, n_Conv3698, n_Cmp5660, 29);
+    ext_grs_edge_t *e_e321 = ext_grs_act_add_edge(pattern, "e321", ext_grs_NO_EDGE_POS, n_Sub2599, n_Phi2663, 30);
+    ext_grs_edge_t *e_pos0_512 = ext_grs_act_add_edge(pattern, "pos0_512", -1, n_Vector_op_Block, n_Cond2398, 31);
+    ext_grs_edge_t *e_e322 = ext_grs_act_add_edge(pattern, "e322", ext_grs_NO_EDGE_POS, n_Sub2625, n_Phi2663, 32);
+    ext_grs_edge_t *e_pos0_514 = ext_grs_act_add_edge(pattern, "pos0_514", -1, n_Block2981, n_Sub3060, 33);
+    ext_grs_edge_t *e_e320 = ext_grs_act_add_edge(pattern, "e320", ext_grs_NO_EDGE_POS, n_Block2577, n_Phi2663, 34);
+    ext_grs_edge_t *e_e733 = ext_grs_act_add_edge(pattern, "e733", ext_grs_NO_EDGE_POS, n_Phi2576, n_Add2544, 35);
+    ext_grs_edge_t *e_pos0_311 = ext_grs_act_add_edge(pattern, "pos0_311", -1, n_Block3155, n_Jmp3235, 36);
+    ext_grs_edge_t *e_pos2_614 = ext_grs_act_add_edge(pattern, "pos2_614", 1, n_Conv3350, n_Sub3382, 37);
+    ext_grs_edge_t *e_pos0_519 = ext_grs_act_add_edge(pattern, "pos0_519", -1, n_Block3329, n_Sub3408, 38);
+    ext_grs_edge_t *e_pos2_373 = ext_grs_act_add_edge(pattern, "pos2_373", 1, n_Conv3176, n_Cmp5654, 39);
+    ext_grs_edge_t *e_pos0_316 = ext_grs_act_add_edge(pattern, "pos0_316", -1, n_Block2751, n_Cond2831, 40);
+    ext_grs_edge_t *e_pos2_371 = ext_grs_act_add_edge(pattern, "pos2_371", 1, n_Conv3263, n_Sub3295, 41);
+    ext_grs_edge_t *e_e734 = ext_grs_act_add_edge(pattern, "e734", ext_grs_NO_EDGE_POS, n_Phi2489, n_Add2544, 42);
+    ext_grs_edge_t *e_pos2_376 = ext_grs_act_add_edge(pattern, "pos2_376", 1, n_Conv2386, n_Sub2452, 43);
+    ext_grs_edge_t *e_e645 = ext_grs_act_add_edge(pattern, "e645", ext_grs_NO_EDGE_POS, n_Proj3267, n_Block3242, 44);
+    ext_grs_edge_t *e_e312 = ext_grs_act_add_edge(pattern, "e312", ext_grs_NO_EDGE_POS, n_Jmp3557, n_Block3534, 45);
+    ext_grs_edge_t *e_pos2_741 = ext_grs_act_add_edge(pattern, "pos2_741", 1, n_Conv2905, n_Sub2973, 46);
+    ext_grs_edge_t *e_e452 = ext_grs_act_add_edge(pattern, "e452", ext_grs_NO_EDGE_POS, n_Block3708, n_Phi3870, 47);
+    ext_grs_edge_t *e_e313 = ext_grs_act_add_edge(pattern, "e313", ext_grs_NO_EDGE_POS, n_Jmp3583, n_Block3534, 48);
+    ext_grs_edge_t *e_e453 = ext_grs_act_add_edge(pattern, "e453", ext_grs_NO_EDGE_POS, n_Sub3730, n_Phi3870, 49);
+    ext_grs_edge_t *e_e454 = ext_grs_act_add_edge(pattern, "e454", ext_grs_NO_EDGE_POS, n_Sub3756, n_Phi3870, 50);
+    ext_grs_edge_t *e_e709 = ext_grs_act_add_edge(pattern, "e709", ext_grs_NO_EDGE_POS, n_Add2544, n_Add2631, 51);
+    ext_grs_edge_t *e_e504 = ext_grs_act_add_edge(pattern, "e504", ext_grs_NO_EDGE_POS, n_Proj2833, n_Block2806, 52);
+    ext_grs_edge_t *e_e456 = ext_grs_act_add_edge(pattern, "e456", ext_grs_NO_EDGE_POS, n_Phi3359, n_Add3327, 53);
+    ext_grs_edge_t *e_e457 = ext_grs_act_add_edge(pattern, "e457", ext_grs_NO_EDGE_POS, n_Add3240, n_Add3327, 54);
+    ext_grs_edge_t *e_e310 = ext_grs_act_add_edge(pattern, "e310", ext_grs_NO_EDGE_POS, n_Proj2745, n_Block2720, 55);
+    ext_grs_edge_t *e_pos2_644 = ext_grs_act_add_edge(pattern, "pos2_644", 1, n_Conv2567, n_Cmp5647, 56);
+    ext_grs_edge_t *e_e705 = ext_grs_act_add_edge(pattern, "e705", ext_grs_NO_EDGE_POS, n_Sub2947, n_Phi3011, 57);
+    ext_grs_edge_t *e_e459 = ext_grs_act_add_edge(pattern, "e459", ext_grs_NO_EDGE_POS, n_Block3012, n_Phi3098, 58);
+    ext_grs_edge_t *e_e706 = ext_grs_act_add_edge(pattern, "e706", ext_grs_NO_EDGE_POS, n_Sub2973, n_Phi3011, 59);
+    ext_grs_edge_t *e_e500 = ext_grs_act_add_edge(pattern, "e500", ext_grs_NO_EDGE_POS, n_Phi3272, n_Add3240, 60);
+    ext_grs_edge_t *e_pos2_467 = ext_grs_act_add_edge(pattern, "pos2_467", 1, n_Conv3437, n_Cmp5657, 61);
+    ext_grs_edge_t *e_pos2_641 = ext_grs_act_add_edge(pattern, "pos2_641", 1, n_Conv3176, n_Sub3208, 62);
+    ext_grs_edge_t *e_e501 = ext_grs_act_add_edge(pattern, "e501", ext_grs_NO_EDGE_POS, n_Add3153, n_Add3240, 63);
+    ext_grs_edge_t *e_e708 = ext_grs_act_add_edge(pattern, "e708", ext_grs_NO_EDGE_POS, n_Phi2663, n_Add2631, 64);
+    ext_grs_edge_t *e_e702 = ext_grs_act_add_edge(pattern, "e702", ext_grs_NO_EDGE_POS, n_Proj2399, n_Block2377, 65);
+    ext_grs_edge_t *e_e701 = ext_grs_act_add_edge(pattern, "e701", ext_grs_NO_EDGE_POS, n_Sub3669, n_Phi3707, 66);
+    ext_grs_edge_t *e_pos0_306 = ext_grs_act_add_edge(pattern, "pos0_306", -1, n_Block3708, n_Vector_Result0_Add3762, 67);
+    ext_grs_edge_t *e_e704 = ext_grs_act_add_edge(pattern, "e704", ext_grs_NO_EDGE_POS, n_Block2925, n_Phi3011, 68);
+    ext_grs_edge_t *e_e700 = ext_grs_act_add_edge(pattern, "e700", ext_grs_NO_EDGE_POS, n_Sub3643, n_Phi3707, 69);
+    ext_grs_edge_t *e_pos0_505 = ext_grs_act_add_edge(pattern, "pos0_505", -1, n_Block2459, n_Jmp2539, 70);
+    ext_grs_edge_t *e_pos0_506 = ext_grs_act_add_edge(pattern, "pos0_506", -1, n_Block3677, n_Sub3756, 71);
+    ext_grs_edge_t *e_pos2_745 = ext_grs_act_add_edge(pattern, "pos2_745", 1, n_Conv3253, n_Sub3321, 72);
+    ext_grs_edge_t *e_pos2_747 = ext_grs_act_add_edge(pattern, "pos2_747", 1, n_Conv2915, n_Cmp5651, 73);
+    ext_grs_edge_t *e_pos0_406 = ext_grs_act_add_edge(pattern, "pos0_406", -1, n_Block3708, n_Add3501, 74);
+    ext_grs_edge_t *e_e307 = ext_grs_act_add_edge(pattern, "e307", ext_grs_NO_EDGE_POS, n_Phi3870, n_Vector_Result0_Add3762, 75);
+    ext_grs_edge_t *e_e656 = ext_grs_act_add_edge(pattern, "e656", ext_grs_NO_EDGE_POS, n_Phi2837, n_Add2805, 76);
+    ext_grs_edge_t *e_e308 = ext_grs_act_add_edge(pattern, "e308", ext_grs_NO_EDGE_POS, n_Add3675, n_Vector_Result0_Add3762, 77);
+    ext_grs_edge_t *e_e305 = ext_grs_act_add_edge(pattern, "e305", ext_grs_NO_EDGE_POS, n_Sub2452, n_Phi2489, 78);
+    ext_grs_edge_t *e_e442 = ext_grs_act_add_edge(pattern, "e442", ext_grs_NO_EDGE_POS, n_Proj3354, n_Block3329, 79);
+    ext_grs_edge_t *e_e303 = ext_grs_act_add_edge(pattern, "e303", ext_grs_NO_EDGE_POS, n_Block2404, n_Phi2489, 80);
+    ext_grs_edge_t *e_e304 = ext_grs_act_add_edge(pattern, "e304", ext_grs_NO_EDGE_POS, n_Sub2426, n_Phi2489, 81);
+    ext_grs_edge_t *e_e657 = ext_grs_act_add_edge(pattern, "e657", ext_grs_NO_EDGE_POS, n_Add2718, n_Add2805, 82);
+    ext_grs_edge_t *e_pos2_592 = ext_grs_act_add_edge(pattern, "pos2_592", 1, n_Conv2644, n_Sub2712, 83);
+    ext_grs_edge_t *e_e300 = ext_grs_act_add_edge(pattern, "e300", ext_grs_NO_EDGE_POS, n_Sub2799, n_Phi2837, 84);
+    ext_grs_edge_t *e_e716 = ext_grs_act_add_edge(pattern, "e716", ext_grs_NO_EDGE_POS, n_Jmp3235, n_Block3186, 85);
+    ext_grs_edge_t *e_e448 = ext_grs_act_add_edge(pattern, "e448", ext_grs_NO_EDGE_POS, n_Proj3268, n_Block3241, 86);
+    ext_grs_edge_t *e_e715 = ext_grs_act_add_edge(pattern, "e715", ext_grs_NO_EDGE_POS, n_Jmp3209, n_Block3186, 87);
+    ext_grs_edge_t *e_pos2_393 = ext_grs_act_add_edge(pattern, "pos2_393", 1, n_Conv2741, n_Sub2773, 88);
+    ext_grs_edge_t *e_e712 = ext_grs_act_add_edge(pattern, "e712", ext_grs_NO_EDGE_POS, n_Sub3321, n_Phi3359, 89);
+    ext_grs_edge_t *e_e711 = ext_grs_act_add_edge(pattern, "e711", ext_grs_NO_EDGE_POS, n_Sub3295, n_Phi3359, 90);
+    ext_grs_edge_t *e_e710 = ext_grs_act_add_edge(pattern, "e710", ext_grs_NO_EDGE_POS, n_Block3273, n_Phi3359, 91);
+    ext_grs_edge_t *e_pos2_635 = ext_grs_act_add_edge(pattern, "pos2_635", 1, n_Conv2828, n_Sub2860, 92);
+    ext_grs_edge_t *e_pos2_737 = ext_grs_act_add_edge(pattern, "pos2_737", 1, n_Conv3601, n_Sub3669, 93);
+    ext_grs_edge_t *e_pos1_291 = ext_grs_act_add_edge(pattern, "pos1_291", 0, n_VProj3165, n_Conv3166, 94);
+    ext_grs_edge_t *e_pos1_293 = ext_grs_act_add_edge(pattern, "pos1_293", 0, n_Cond2398, n_Proj2399, 95);
+    ext_grs_edge_t *e_pos1_294 = ext_grs_act_add_edge(pattern, "pos1_294", 0, n_Arg_0, n_VProj3426, 96);
+    ext_grs_edge_t *e_pos2_398 = ext_grs_act_add_edge(pattern, "pos2_398", 1, n_Conv3089, n_Sub3121, 97);
+    ext_grs_edge_t *e_pos1_297 = ext_grs_act_add_edge(pattern, "pos1_297", 0, n_VProj2556, n_Conv2557, 98);
+    ext_grs_edge_t *e_pos2_661 = ext_grs_act_add_edge(pattern, "pos2_661", 1, n_Conv2654, n_Cmp5648, 99);
+    ext_grs_edge_t *e_pos0_564 = ext_grs_act_add_edge(pattern, "pos0_564", -1, n_Block3708, n_Add3066, 100);
+    ext_grs_edge_t *e_e478 = ext_grs_act_add_edge(pattern, "e478", ext_grs_NO_EDGE_POS, n_Sub3556, n_Phi3620, 101);
+    ext_grs_edge_t *e_e477 = ext_grs_act_add_edge(pattern, "e477", ext_grs_NO_EDGE_POS, n_Block3534, n_Phi3620, 102);
+    ext_grs_edge_t *e_pos0_568 = ext_grs_act_add_edge(pattern, "pos0_568", -1, n_Block3676, n_Jmp3731, 103);
+    ext_grs_edge_t *e_e479 = ext_grs_act_add_edge(pattern, "e479", ext_grs_NO_EDGE_POS, n_Sub3582, n_Phi3620, 104);
+    ext_grs_edge_t *e_pos0_426 = ext_grs_act_add_edge(pattern, "pos0_426", -1, n_Block3241, n_Jmp3296, 105);
+    ext_grs_edge_t *e_pos0_694 = ext_grs_act_add_edge(pattern, "pos0_694", -1, n_Block2458, n_Sub2512, 106);
+    ext_grs_edge_t *e_pos0_424 = ext_grs_act_add_edge(pattern, "pos0_424", -1, n_Block3502, n_Jmp3557, 107);
+    ext_grs_edge_t *e_pos0_562 = ext_grs_act_add_edge(pattern, "pos0_562", -1, n_Block3416, n_Jmp3496, 108);
+    ext_grs_edge_t *e_pos0_560 = ext_grs_act_add_edge(pattern, "pos0_560", -1, n_Block3273, n_Cond3353, 109);
+    ext_grs_edge_t *e_pos1_389 = ext_grs_act_add_edge(pattern, "pos1_389", 0, n_Proj3091, n_Cond3092, 110);
+    ext_grs_edge_t *e_pos1_387 = ext_grs_act_add_edge(pattern, "pos1_387", 0, n_Proj3613, n_Cond3614, 111);
+    ext_grs_edge_t *e_pos0_429 = ext_grs_act_add_edge(pattern, "pos0_429", -1, n_Block3708, n_Add3414, 112);
+    ext_grs_edge_t *e_pos1_381 = ext_grs_act_add_edge(pattern, "pos1_381", 0, n_VProj2479, n_Conv2480, 113);
+    ext_grs_edge_t *e_pos1_380 = ext_grs_act_add_edge(pattern, "pos1_380", 0, n_Proj2569, n_Cond2570, 114);
+    ext_grs_edge_t *e_pos1_384 = ext_grs_act_add_edge(pattern, "pos1_384", 0, n_Conv3427, n_Sub3469, 115);
+    ext_grs_edge_t *e_e364 = ext_grs_act_add_edge(pattern, "e364", ext_grs_NO_EDGE_POS, n_Add3501, n_Add3588, 116);
+    ext_grs_edge_t *e_e363 = ext_grs_act_add_edge(pattern, "e363", ext_grs_NO_EDGE_POS, n_Phi3620, n_Add3588, 117);
+    ext_grs_edge_t *e_e465 = ext_grs_act_add_edge(pattern, "e465", ext_grs_NO_EDGE_POS, n_Sub3408, n_Phi3446, 118);
+    ext_grs_edge_t *e_e464 = ext_grs_act_add_edge(pattern, "e464", ext_grs_NO_EDGE_POS, n_Sub3382, n_Phi3446, 119);
+    ext_grs_edge_t *e_e463 = ext_grs_act_add_edge(pattern, "e463", ext_grs_NO_EDGE_POS, n_Block3360, n_Phi3446, 120);
+    ext_grs_edge_t *e_pos2_339 = ext_grs_act_add_edge(pattern, "pos2_339", 1, n_Conv3089, n_Cmp5653, 121);
+    ext_grs_edge_t *e_e461 = ext_grs_act_add_edge(pattern, "e461", ext_grs_NO_EDGE_POS, n_Sub3060, n_Phi3098, 122);
+    ext_grs_edge_t *e_e460 = ext_grs_act_add_edge(pattern, "e460", ext_grs_NO_EDGE_POS, n_Sub3034, n_Phi3098, 123);
+    ext_grs_edge_t *e_pos1_375 = ext_grs_act_add_edge(pattern, "pos1_375", 0, n_Conv2395, n_Sub2452, 124);
+    ext_grs_edge_t *e_pos1_378 = ext_grs_act_add_edge(pattern, "pos1_378", 0, n_Proj3178, n_Cond3179, 125);
+    ext_grs_edge_t *e_pos2_337 = ext_grs_act_add_edge(pattern, "pos2_337", 1, n_Conv2731, n_Sub2799, 126);
+    ext_grs_edge_t *e_pos0_419 = ext_grs_act_add_edge(pattern, "pos0_419", -1, n_Block3329, n_Jmp3409, 127);
+    ext_grs_edge_t *e_pos1_370 = ext_grs_act_add_edge(pattern, "pos1_370", 0, n_Conv3253, n_Sub3295, 128);
+    ext_grs_edge_t *e_pos1_372 = ext_grs_act_add_edge(pattern, "pos1_372", 0, n_Conv3166, n_Cmp5654, 129);
+    ext_grs_edge_t *e_e352 = ext_grs_act_add_edge(pattern, "e352", ext_grs_NO_EDGE_POS, n_Jmp3409, n_Block3360, 130);
+    ext_grs_edge_t *e_pos0_543 = ext_grs_act_add_edge(pattern, "pos0_543", -1, n_Block3155, n_Sub3234, 131);
+    ext_grs_edge_t *e_e351 = ext_grs_act_add_edge(pattern, "e351", ext_grs_NO_EDGE_POS, n_Jmp3383, n_Block3360, 132);
+    ext_grs_edge_t *e_pos2_685 = ext_grs_act_add_edge(pattern, "pos2_685", 1, n_Conv2741, n_Cmp5649, 133);
+    ext_grs_edge_t *e_pos0_542 = ext_grs_act_add_edge(pattern, "pos0_542", -1, n_Block3328, n_Jmp3383, 134);
+    ext_grs_edge_t *e_e492 = ext_grs_act_add_edge(pattern, "e492", ext_grs_NO_EDGE_POS, n_Sub3208, n_Phi3272, 135);
+    ext_grs_edge_t *e_pos0_444 = ext_grs_act_add_edge(pattern, "pos0_444", -1, n_Block2545, n_Sub2599, 136);
+    ext_grs_edge_t *e_e491 = ext_grs_act_add_edge(pattern, "e491", ext_grs_NO_EDGE_POS, n_Block3186, n_Phi3272, 137);
+    ext_grs_edge_t *e_e494 = ext_grs_act_add_edge(pattern, "e494", ext_grs_NO_EDGE_POS, n_Proj2659, n_Block2632, 138);
+    ext_grs_edge_t *e_e600 = ext_grs_act_add_edge(pattern, "e600", ext_grs_NO_EDGE_POS, n_Proj2920, n_Block2893, 139);
+    ext_grs_edge_t *e_e493 = ext_grs_act_add_edge(pattern, "e493", ext_grs_NO_EDGE_POS, n_Sub3234, n_Phi3272, 140);
+    ext_grs_edge_t *e_e495 = ext_grs_act_add_edge(pattern, "e495", ext_grs_NO_EDGE_POS, n_Proj2658, n_Block2633, 141);
+    ext_grs_edge_t *e_pos0_449 = ext_grs_act_add_edge(pattern, "pos0_449", -1, n_Block2632, n_Jmp2687, 142);
+    ext_grs_edge_t *e_e498 = ext_grs_act_add_edge(pattern, "e498", ext_grs_NO_EDGE_POS, n_Jmp3496, n_Block3447, 143);
+    ext_grs_edge_t *e_e497 = ext_grs_act_add_edge(pattern, "e497", ext_grs_NO_EDGE_POS, n_Jmp3470, n_Block3447, 144);
+    ext_grs_edge_t *e_e606 = ext_grs_act_add_edge(pattern, "e606", ext_grs_NO_EDGE_POS, n_Proj2832, n_Block2807, 145);
+    ext_grs_edge_t *e_pos2_368 = ext_grs_act_add_edge(pattern, "pos2_368", 1, n_Conv2915, n_Sub2947, 146);
+    ext_grs_edge_t *e_pos2_361 = ext_grs_act_add_edge(pattern, "pos2_361", 1, n_Conv3611, n_Sub3643, 147);
+    ext_grs_edge_t *e_pos0_536 = ext_grs_act_add_edge(pattern, "pos0_536", -1, n_Block2807, n_Sub2886, 148);
+    ext_grs_edge_t *e_e489 = ext_grs_act_add_edge(pattern, "e489", ext_grs_NO_EDGE_POS, n_Sub2860, n_Phi2924, 149);
+    ext_grs_edge_t *e_e488 = ext_grs_act_add_edge(pattern, "e488", ext_grs_NO_EDGE_POS, n_Block2838, n_Phi2924, 150);
+    ext_grs_edge_t *e_pos2_674 = ext_grs_act_add_edge(pattern, "pos2_674", 1, n_Conv2654, n_Sub2686, 151);
+    ext_grs_edge_t *e_pos0_532 = ext_grs_act_add_edge(pattern, "pos0_532", -1, n_Block3503, n_Sub3582, 152);
+    ext_grs_edge_t *e_e346 = ext_grs_act_add_edge(pattern, "e346", ext_grs_NO_EDGE_POS, n_Proj3442, n_Block3415, 153);
+    ext_grs_edge_t *e_pos0_439 = ext_grs_act_add_edge(pattern, "pos0_439", -1, n_Block3447, n_Cond3527, 154);
+    ext_grs_edge_t *e_e617 = ext_grs_act_add_edge(pattern, "e617", ext_grs_NO_EDGE_POS, n_Jmp3644, n_Block3621, 155);
+    ext_grs_edge_t *e_e618 = ext_grs_act_add_edge(pattern, "e618", ext_grs_NO_EDGE_POS, n_Jmp3670, n_Block3621, 156);
+    ext_grs_edge_t *e_e490 = ext_grs_act_add_edge(pattern, "e490", ext_grs_NO_EDGE_POS, n_Sub2886, n_Phi2924, 157);
+    ext_grs_edge_t *e_pos1_397 = ext_grs_act_add_edge(pattern, "pos1_397", 0, n_Conv3079, n_Sub3121, 158);
+    ext_grs_edge_t *e_pos1_394 = ext_grs_act_add_edge(pattern, "pos1_394", 0, n_Arg_0, n_VProj3513, 159);
+    ext_grs_edge_t *e_pos2_350 = ext_grs_act_add_edge(pattern, "pos2_350", 1, n_Conv2557, n_Sub2625, 160);
+    ext_grs_edge_t *e_pos0_539 = ext_grs_act_add_edge(pattern, "pos0_539", -1, n_Block3708, n_Add3153, 161);
+    ext_grs_edge_t *e_pos1_392 = ext_grs_act_add_edge(pattern, "pos1_392", 0, n_Conv2731, n_Sub2773, 162);
+    ext_grs_edge_t *e_pos1_340 = ext_grs_act_add_edge(pattern, "pos1_340", 0, n_Arg_1, n_VProj2740, 163);
+    ext_grs_edge_t *e_pos1_341 = ext_grs_act_add_edge(pattern, "pos1_341", 0, n_Cmp5650, n_Proj2830, 164);
+    ext_grs_edge_t *e_pos1_342 = ext_grs_act_add_edge(pattern, "pos1_342", 0, n_Cond3092, n_Proj3094, 165);
+    ext_grs_edge_t *e_pos1_343 = ext_grs_act_add_edge(pattern, "pos1_343", 0, n_Cond2483, n_Proj2485, 166);
+    ext_grs_edge_t *e_pos1_345 = ext_grs_act_add_edge(pattern, "pos1_345", 0, n_Cond3527, n_Proj3529, 167);
+    ext_grs_edge_t *e_pos1_626 = ext_grs_act_add_edge(pattern, "pos1_626", 0, n_Arg_1, n_VProj3697, 168);
+    ext_grs_edge_t *e_pos1_347 = ext_grs_act_add_edge(pattern, "pos1_347", 0, n_Cond3005, n_Proj3007, 169);
+    ext_grs_edge_t *e_pos1_628 = ext_grs_act_add_edge(pattern, "pos1_628", 0, n_Conv3514, n_Sub3556, 170);
+    ext_grs_edge_t *e_pos1_349 = ext_grs_act_add_edge(pattern, "pos1_349", 0, n_Conv2567, n_Sub2625, 171);
+    ext_grs_edge_t *e_pos1_622 = ext_grs_act_add_edge(pattern, "pos1_622", 0, n_Arg_0, n_VProj2385, 172);
+    ext_grs_edge_t *e_pos0_468 = ext_grs_act_add_edge(pattern, "pos0_468", -1, n_Block2376, n_Sub2426, 173);
+    ext_grs_edge_t *e_pos1_623 = ext_grs_act_add_edge(pattern, "pos1_623", 0, n_Arg_1, n_VProj2653, 174);
+    ext_grs_edge_t *e_pos1_620 = ext_grs_act_add_edge(pattern, "pos1_620", 0, n_Conv2480, n_Sub2538, 175);
+    ext_grs_edge_t *e_pos0_655 = ext_grs_act_add_edge(pattern, "pos0_655", -1, n_Block3708, n_Add2805, 176);
+    ext_grs_edge_t *e_pos0_462 = ext_grs_act_add_edge(pattern, "pos0_462", -1, n_Block2806, n_Jmp2861, 177);
+    ext_grs_edge_t *e_pos0_651 = ext_grs_act_add_edge(pattern, "pos0_651", -1, n_Block3360, n_Cond3440, 178);
+    ext_grs_edge_t *e_pos1_333 = ext_grs_act_add_edge(pattern, "pos1_333", 0, n_Arg_1, n_VProj3001, 179);
+    ext_grs_edge_t *e_pos0_390 = ext_grs_act_add_edge(pattern, "pos0_390", -1, n_Block2894, n_Jmp2974, 180);
+    ext_grs_edge_t *e_pos0_391 = ext_grs_act_add_edge(pattern, "pos0_391", -1, n_Block2719, n_Sub2773, 181);
+    ext_grs_edge_t *e_pos1_616 = ext_grs_act_add_edge(pattern, "pos1_616", 0, n_VProj2730, n_Conv2731, 182);
+    ext_grs_edge_t *e_pos0_396 = ext_grs_act_add_edge(pattern, "pos0_396", -1, n_Block3067, n_Sub3121, 183);
+    ext_grs_edge_t *e_pos1_338 = ext_grs_act_add_edge(pattern, "pos1_338", 0, n_Conv3079, n_Cmp5653, 184);
+    ext_grs_edge_t *e_pos1_615 = ext_grs_act_add_edge(pattern, "pos1_615", 0, n_Arg_1, n_VProj3262, 185);
+    ext_grs_edge_t *e_pos1_336 = ext_grs_act_add_edge(pattern, "pos1_336", 0, n_Conv2741, n_Sub2799, 186);
+    ext_grs_edge_t *e_pos1_613 = ext_grs_act_add_edge(pattern, "pos1_613", 0, n_Conv3340, n_Sub3382, 187);
+    ext_grs_edge_t *e_pos0_590 = ext_grs_act_add_edge(pattern, "pos0_590", -1, n_Block2633, n_Sub2712, 188);
+    ext_grs_edge_t *e_pos1_610 = ext_grs_act_add_edge(pattern, "pos1_610", 0, n_VProj2394, n_Conv2395, 189);
+    ext_grs_edge_t *e_pos0_594 = ext_grs_act_add_edge(pattern, "pos0_594", -1, n_Block3708, n_Add2979, 190);
+    ext_grs_edge_t *e_pos0_455 = ext_grs_act_add_edge(pattern, "pos0_455", -1, n_Block3708, n_Add3327, 191);
+    ext_grs_edge_t *e_pos1_751 = ext_grs_act_add_edge(pattern, "pos1_751", 0, n_Cond3005, n_Proj3006, 192);
+    ext_grs_edge_t *e_pos1_750 = ext_grs_act_add_edge(pattern, "pos1_750", 0, n_Proj2482, n_Cond2483, 193);
+    ext_grs_edge_t *e_pos0_667 = ext_grs_act_add_edge(pattern, "pos0_667", -1, n_Block2981, n_Jmp3061, 194);
+    ext_grs_edge_t *e_pos0_597 = ext_grs_act_add_edge(pattern, "pos0_597", -1, n_Block2838, n_Cond2918, 195);
+    ext_grs_edge_t *e_pos0_450 = ext_grs_act_add_edge(pattern, "pos0_450", -1, n_Block2633, n_Jmp2713, 196);
+    ext_grs_edge_t *e_pos0_663 = ext_grs_act_add_edge(pattern, "pos0_663", -1, n_Block2719, n_Jmp2774, 197);
+    ext_grs_edge_t *e_pos0_662 = ext_grs_act_add_edge(pattern, "pos0_662", -1, n_Block3590, n_Jmp3670, 198);
+    ext_grs_edge_t *e_pos1_360 = ext_grs_act_add_edge(pattern, "pos1_360", 0, n_Conv3601, n_Sub3643, 199);
+    ext_grs_edge_t *e_pos1_746 = ext_grs_act_add_edge(pattern, "pos1_746", 0, n_Conv2905, n_Cmp5651, 200);
+    ext_grs_edge_t *e_pos0_388 = ext_grs_act_add_edge(pattern, "pos0_388", -1, n_Block3012, n_Cond3092, 201);
+    ext_grs_edge_t *e_pos1_748 = ext_grs_act_add_edge(pattern, "pos1_748", 0, n_Cond2744, n_Proj2746, 202);
+    ext_grs_edge_t *e_pos1_647 = ext_grs_act_add_edge(pattern, "pos1_647", 0, n_Arg_0, n_VProj2730, 203);
+    ext_grs_edge_t *e_pos0_383 = ext_grs_act_add_edge(pattern, "pos0_383", -1, n_Block3415, n_Sub3469, 204);
+    ext_grs_edge_t *e_pos0_386 = ext_grs_act_add_edge(pattern, "pos0_386", -1, n_Block3534, n_Cond3614, 205);
+    ext_grs_edge_t *e_pos1_367 = ext_grs_act_add_edge(pattern, "pos1_367", 0, n_Conv2905, n_Sub2947, 206);
+    ext_grs_edge_t *e_pos1_640 = ext_grs_act_add_edge(pattern, "pos1_640", 0, n_Conv3166, n_Sub3208, 207);
+    ext_grs_edge_t *e_e585 = ext_grs_act_add_edge(pattern, "e585", ext_grs_NO_EDGE_POS, n_Jmp2626, n_Block2577, 208);
+    ext_grs_edge_t *e_pos0_581 = ext_grs_act_add_edge(pattern, "pos0_581", -1, n_Block2664, n_Cond2744, 209);
+    ext_grs_edge_t *e_pos1_642 = ext_grs_act_add_edge(pattern, "pos1_642", 0, n_Cmp5651, n_Proj2917, 210);
+    ext_grs_edge_t *e_e584 = ext_grs_act_add_edge(pattern, "e584", ext_grs_NO_EDGE_POS, n_Jmp2600, n_Block2577, 211);
+    ext_grs_edge_t *e_pos1_643 = ext_grs_act_add_edge(pattern, "pos1_643", 0, n_Conv2557, n_Cmp5647, 212);
+    ext_grs_edge_t *e_pos0_672 = ext_grs_act_add_edge(pattern, "pos0_672", -1, n_Block2632, n_Sub2686, 213);
+    ext_grs_edge_t *e_pos1_646 = ext_grs_act_add_edge(pattern, "pos1_646", 0, n_Arg_1, n_VProj2394, 214);
+    ext_grs_edge_t *e_pos0_671 = ext_grs_act_add_edge(pattern, "pos0_671", -1, n_Block2377, n_Jmp2453, 215);
+    ext_grs_edge_t *e_pos1_742 = ext_grs_act_add_edge(pattern, "pos1_742", 0, n_Cond3614, n_Proj3615, 216);
+    ext_grs_edge_t *e_pos0_481 = ext_grs_act_add_edge(pattern, "pos0_481", -1, n_Block2577, n_Cond2657, 217);
+    ext_grs_edge_t *e_pos1_744 = ext_grs_act_add_edge(pattern, "pos1_744", 0, n_Conv3263, n_Sub3321, 218);
+    ext_grs_edge_t *e_pos0_675 = ext_grs_act_add_edge(pattern, "pos0_675", -1, n_Block3708, n_Add2718, 219);
+    ext_grs_edge_t *e_pos0_678 = ext_grs_act_add_edge(pattern, "pos0_678", -1, n_Block2925, n_Cond3005, 220);
+    ext_grs_edge_t *e_e589 = ext_grs_act_add_edge(pattern, "e589", ext_grs_NO_EDGE_POS, n_Proj3441, n_Block3416, 221);
+    ext_grs_edge_t *e_pos0_483 = ext_grs_act_add_edge(pattern, "pos0_483", -1, n_Block3677, n_Jmp3757, 222);
+    ext_grs_edge_t *e_pos1_740 = ext_grs_act_add_edge(pattern, "pos1_740", 0, n_Conv2915, n_Sub2973, 223);
+    ext_grs_edge_t *e_pos0_484 = ext_grs_act_add_edge(pattern, "pos0_484", -1, n_Block3621, n_Cond3701, 224);
+    ext_grs_edge_t *e_pos0_379 = ext_grs_act_add_edge(pattern, "pos0_379", -1, n_Block2490, n_Cond2570, 225);
+    ext_grs_edge_t *e_pos1_736 = ext_grs_act_add_edge(pattern, "pos1_736", 0, n_Conv3611, n_Sub3669, 226);
+    ext_grs_edge_t *e_pos0_377 = ext_grs_act_add_edge(pattern, "pos0_377", -1, n_Block3099, n_Cond3179, 227);
+    ext_grs_edge_t *e_pos0_374 = ext_grs_act_add_edge(pattern, "pos0_374", -1, n_Block2377, n_Sub2452, 228);
+    ext_grs_edge_t *e_pos1_357 = ext_grs_act_add_edge(pattern, "pos1_357", 0, n_VProj3252, n_Conv3253, 229);
+    ext_grs_edge_t *e_pos1_358 = ext_grs_act_add_edge(pattern, "pos1_358", 0, n_Cond2744, n_Proj2745, 230);
+    ext_grs_edge_t *e_pos1_353 = ext_grs_act_add_edge(pattern, "pos1_353", 0, n_VProj3513, n_Conv3514, 231);
+    ext_grs_edge_t *e_pos1_630 = ext_grs_act_add_edge(pattern, "pos1_630", 0, n_Cond3353, n_Proj3355, 232);
+    ext_grs_edge_t *e_e595 = ext_grs_act_add_edge(pattern, "e595", ext_grs_NO_EDGE_POS, n_Phi3011, n_Add2979, 233);
+    ext_grs_edge_t *e_e596 = ext_grs_act_add_edge(pattern, "e596", ext_grs_NO_EDGE_POS, n_Add2892, n_Add2979, 234);
+    ext_grs_edge_t *e_pos0_571 = ext_grs_act_add_edge(pattern, "pos0_571", -1, n_Block2893, n_Jmp2948, 235);
+    ext_grs_edge_t *e_pos1_634 = ext_grs_act_add_edge(pattern, "pos1_634", 0, n_Conv2818, n_Sub2860, 236);
+    ext_grs_edge_t *e_pos1_730 = ext_grs_act_add_edge(pattern, "pos1_730", 0, n_VProj3436, n_Conv3437, 237);
+    ext_grs_edge_t *e_pos0_577 = ext_grs_act_add_edge(pattern, "pos0_577", -1, n_Block2807, n_Jmp2887, 238);
+    ext_grs_edge_t *e_e599 = ext_grs_act_add_edge(pattern, "e599", ext_grs_NO_EDGE_POS, n_Proj3703, n_Block3676, 239);
+    ext_grs_edge_t *e_pos0_471 = ext_grs_act_add_edge(pattern, "pos0_471", -1, n_Block3186, n_Cond3266, 240);
+    ext_grs_edge_t *e_pos2_728 = ext_grs_act_add_edge(pattern, "pos2_728", 1, n_Conv3427, n_Sub3495, 241);
+    ext_grs_edge_t *e_pos1_301 = ext_grs_act_add_edge(pattern, "pos1_301", 0, n_VProj3600, n_Conv3601, 242);
+    ext_grs_edge_t *e_pos0_362 = ext_grs_act_add_edge(pattern, "pos0_362", -1, n_Block3708, n_Add3588, 243);
+    ext_grs_edge_t *e_pos2_725 = ext_grs_act_add_edge(pattern, "pos2_725", 1, n_Conv3079, n_Sub3147, 244);
+    ext_grs_edge_t *e_pos1_302 = ext_grs_act_add_edge(pattern, "pos1_302", 0, n_VProj3078, n_Conv3079, 245);
+    ext_grs_edge_t *e_pos0_366 = ext_grs_act_add_edge(pattern, "pos0_366", -1, n_Block2893, n_Sub2947, 246);
+    ext_grs_edge_t *e_pos1_724 = ext_grs_act_add_edge(pattern, "pos1_724", 0, n_Conv3089, n_Sub3147, 247);
+    ext_grs_edge_t *e_pos0_619 = ext_grs_act_add_edge(pattern, "pos0_619", -1, n_Block2459, n_Sub2538, 248);
+    ext_grs_edge_t *e_pos0_365 = ext_grs_act_add_edge(pattern, "pos0_365", -1, n_Block3503, n_Jmp3583, 249);
+    ext_grs_edge_t *e_pos1_727 = ext_grs_act_add_edge(pattern, "pos1_727", 0, n_Conv3437, n_Sub3495, 250);
+    ext_grs_edge_t *e_pos1_520 = ext_grs_act_add_edge(pattern, "pos1_520", 0, n_Conv3350, n_Sub3408, 251);
+    ext_grs_edge_t *e_pos1_729 = ext_grs_act_add_edge(pattern, "pos1_729", 0, n_VProj3426, n_Conv3427, 252);
+    ext_grs_edge_t *e_pos1_522 = ext_grs_act_add_edge(pattern, "pos1_522", 0, n_Cmp5655, n_Proj3265, 253);
+    ext_grs_edge_t *e_pos0_369 = ext_grs_act_add_edge(pattern, "pos0_369", -1, n_Block3241, n_Sub3295, 254);
+    ext_grs_edge_t *e_pos1_525 = ext_grs_act_add_edge(pattern, "pos1_525", 0, n_Cond3353, n_Proj3354, 255);
+    ext_grs_edge_t *e_pos0_611 = ext_grs_act_add_edge(pattern, "pos0_611", -1, n_Block3242, n_Jmp3322, 256);
+    ext_grs_edge_t *e_pos0_612 = ext_grs_act_add_edge(pattern, "pos0_612", -1, n_Block3328, n_Sub3382, 257);
+    ext_grs_edge_t *e_pos1_527 = ext_grs_act_add_edge(pattern, "pos1_527", 0, n_Arg_1, n_VProj3610, 258);
+    ext_grs_edge_t *e_e566 = ext_grs_act_add_edge(pattern, "e566", ext_grs_NO_EDGE_POS, n_Add2979, n_Add3066, 259);
+    ext_grs_edge_t *e_pos1_528 = ext_grs_act_add_edge(pattern, "pos1_528", 0, n_Arg_1, n_VProj3088, 260);
+    ext_grs_edge_t *e_e565 = ext_grs_act_add_edge(pattern, "e565", ext_grs_NO_EDGE_POS, n_Phi3098, n_Add3066, 261);
+    ext_grs_edge_t *e_pos1_529 = ext_grs_act_add_edge(pattern, "pos1_529", 0, n_Cmp5648, n_Proj2656, 262);
+    ext_grs_edge_t *e_pos1_720 = ext_grs_act_add_edge(pattern, "pos1_720", 0, n_Cond2398, n_Proj2400, 263);
+    ext_grs_edge_t *e_pos1_721 = ext_grs_act_add_edge(pattern, "pos1_721", 0, n_Cond2570, n_Proj2571, 264);
+    ext_grs_edge_t *e_pos1_309 = ext_grs_act_add_edge(pattern, "pos1_309", 0, n_VProj3001, n_Conv3002, 265);
+    ext_grs_edge_t *e_e666 = ext_grs_act_add_edge(pattern, "e666", ext_grs_NO_EDGE_POS, n_Proj2571, n_Block2546, 266);
+    ext_grs_edge_t *e_e563 = ext_grs_act_add_edge(pattern, "e563", ext_grs_NO_EDGE_POS, n_Proj3355, n_Block3328, 267);
+    ext_grs_edge_t *e_e664 = ext_grs_act_add_edge(pattern, "e664", ext_grs_NO_EDGE_POS, n_Proj2400, n_Block2376, 268);
+    ext_grs_edge_t *e_pos2_718 = ext_grs_act_add_edge(pattern, "pos2_718", 1, n_Conv2828, n_Cmp5650, 269);
+    ext_grs_edge_t *e_pos0_356 = ext_grs_act_add_edge(pattern, "pos0_356", -1, n_Block3067, n_Jmp3122, 270);
+    ext_grs_edge_t *e_pos1_714 = ext_grs_act_add_edge(pattern, "pos1_714", 0, n_Cmp5652, n_Proj3004, 271);
+    ext_grs_edge_t *e_pos0_355 = ext_grs_act_add_edge(pattern, "pos0_355", -1, n_Block3589, n_Jmp3644, 272);
+    ext_grs_edge_t *e_pos1_713 = ext_grs_act_add_edge(pattern, "pos1_713", 0, n_Arg_1, n_VProj2914, 273);
+    ext_grs_edge_t *e_pos0_354 = ext_grs_act_add_edge(pattern, "pos0_354", -1, n_Block2545, n_Jmp2600, 274);
+    ext_grs_edge_t *e_pos1_719 = ext_grs_act_add_edge(pattern, "pos1_719", 0, n_Cmp5649, n_Proj2743, 275);
+    ext_grs_edge_t *e_pos1_513 = ext_grs_act_add_edge(pattern, "pos1_513", 0, n_Proj2397, n_Cond2398, 276);
+    ext_grs_edge_t *e_pos0_627 = ext_grs_act_add_edge(pattern, "pos0_627", -1, n_Block3502, n_Sub3556, 277);
+    ext_grs_edge_t *e_pos0_359 = ext_grs_act_add_edge(pattern, "pos0_359", -1, n_Block3589, n_Sub3643, 278);
+    ext_grs_edge_t *e_pos1_717 = ext_grs_act_add_edge(pattern, "pos1_717", 0, n_Conv2818, n_Cmp5650, 279);
+    ext_grs_edge_t *e_pos1_511 = ext_grs_act_add_edge(pattern, "pos1_511", 0, n_VProj2904, n_Conv2905, 280);
+    ext_grs_edge_t *e_pos1_517 = ext_grs_act_add_edge(pattern, "pos1_517", 0, n_Arg_1, n_VProj3175, 281);
+    ext_grs_edge_t *e_pos1_518 = ext_grs_act_add_edge(pattern, "pos1_518", 0, n_Arg_1, n_VProj2566, 282);
+    ext_grs_edge_t *e_pos0_496 = ext_grs_act_add_edge(pattern, "pos0_496", -1, n_Block3068, n_Jmp3148, 283);
+    ext_grs_edge_t *e_pos1_515 = ext_grs_act_add_edge(pattern, "pos1_515", 0, n_Conv3002, n_Sub3060, 284);
+    ext_grs_edge_t *e_e676 = ext_grs_act_add_edge(pattern, "e676", ext_grs_NO_EDGE_POS, n_Phi2750, n_Add2718, 285);
+    ext_grs_edge_t *e_e573 = ext_grs_act_add_edge(pattern, "e573", ext_grs_NO_EDGE_POS, n_Sub2512, n_Phi2576, 286);
+    ext_grs_edge_t *e_pos0_499 = ext_grs_act_add_edge(pattern, "pos0_499", -1, n_Block3708, n_Add3240, 287);
+    ext_grs_edge_t *e_e572 = ext_grs_act_add_edge(pattern, "e572", ext_grs_NO_EDGE_POS, n_Block2490, n_Phi2576, 288);
+    ext_grs_edge_t *e_e677 = ext_grs_act_add_edge(pattern, "e677", ext_grs_NO_EDGE_POS, n_Add2631, n_Add2718, 289);
+    ext_grs_edge_t *e_e574 = ext_grs_act_add_edge(pattern, "e574", ext_grs_NO_EDGE_POS, n_Sub2538, n_Phi2576, 290);
+    ext_grs_edge_t *e_pos1_604 = ext_grs_act_add_edge(pattern, "pos1_604", 0, n_Conv2470, n_Cmp5646, 291);
+    ext_grs_edge_t *e_pos1_327 = ext_grs_act_add_edge(pattern, "pos1_327", 0, n_Arg_0, n_VProj2556, 292);
+    ext_grs_edge_t *e_pos1_608 = ext_grs_act_add_edge(pattern, "pos1_608", 0, n_Conv2992, n_Sub3034, 293);
+    ext_grs_edge_t *e_pos1_402 = ext_grs_act_add_edge(pattern, "pos1_402", 0, n_Arg_0, n_VProj3252, 294);
+    ext_grs_edge_t *e_pos1_401 = ext_grs_act_add_edge(pattern, "pos1_401", 0, n_VProj2643, n_Conv2644, 295);
+    ext_grs_edge_t *e_pos0_739 = ext_grs_act_add_edge(pattern, "pos0_739", -1, n_Block2894, n_Sub2973, 296);
+    ext_grs_edge_t *e_pos1_323 = ext_grs_act_add_edge(pattern, "pos1_323", 0, n_Arg_0, n_VProj3165, 297);
+    ext_grs_edge_t *e_pos0_738 = ext_grs_act_add_edge(pattern, "pos0_738", -1, n_Block2720, n_Jmp2800, 298);
+    ext_grs_edge_t *e_pos2_609 = ext_grs_act_add_edge(pattern, "pos2_609", 1, n_Conv3002, n_Sub3034, 299);
+    ext_grs_edge_t *e_pos0_348 = ext_grs_act_add_edge(pattern, "pos0_348", -1, n_Block2546, n_Sub2625, 300);
+    ext_grs_edge_t *e_pos1_503 = ext_grs_act_add_edge(pattern, "pos1_503", 0, n_VProj3687, n_Conv3688, 301);
+    ext_grs_edge_t *e_pos0_639 = ext_grs_act_add_edge(pattern, "pos0_639", -1, n_Block3154, n_Sub3208, 302);
+    ext_grs_edge_t *e_pos1_502 = ext_grs_act_add_edge(pattern, "pos1_502", 0, n_Arg_0, n_VProj3339, 303);
+    ext_grs_edge_t *e_pos1_703 = ext_grs_act_add_edge(pattern, "pos1_703", 0, n_Arg_0, n_VProj2991, 304);
+    ext_grs_edge_t *e_pos2_605 = ext_grs_act_add_edge(pattern, "pos2_605", 1, n_Conv2480, n_Cmp5646, 305);
+    ext_grs_edge_t *e_pos0_344 = ext_grs_act_add_edge(pattern, "pos0_344", -1, n_Block3154, n_Jmp3209, 306);
+    ext_grs_edge_t *e_pos2_603 = ext_grs_act_add_edge(pattern, "pos2_603", 1, n_Conv3698, n_Sub3730, 307);
+    ext_grs_edge_t *e_e681 = ext_grs_act_add_edge(pattern, "e681", ext_grs_NO_EDGE_POS, n_Jmp2774, n_Block2751, 308);
+    ext_grs_edge_t *e_pos1_509 = ext_grs_act_add_edge(pattern, "pos1_509", 0, n_Conv3514, n_Cmp5658, 309);
+    ext_grs_edge_t *e_pos0_633 = ext_grs_act_add_edge(pattern, "pos0_633", -1, n_Block2806, n_Sub2860, 310);
+    ext_grs_edge_t *e_e546 = ext_grs_act_add_edge(pattern, "e546", ext_grs_NO_EDGE_POS, n_Proj2484, n_Block2459, 311);
+    ext_grs_edge_t *e_e418 = ext_grs_act_add_edge(pattern, "e418", ext_grs_NO_EDGE_POS, n_Proj2919, n_Block2894, 312);
+    ext_grs_edge_t *e_e682 = ext_grs_act_add_edge(pattern, "e682", ext_grs_NO_EDGE_POS, n_Jmp2800, n_Block2751, 313);
+    ext_grs_edge_t *e_pos0_636 = ext_grs_act_add_edge(pattern, "pos0_636", -1, n_Block3708, n_Add2892, 314);
+    ext_grs_edge_t *e_pos1_507 = ext_grs_act_add_edge(pattern, "pos1_507", 0, n_Conv3698, n_Sub3756, 315);
+    ext_grs_edge_t *e_pos0_732 = ext_grs_act_add_edge(pattern, "pos0_732", -1, n_Block3708, n_Add2544, 316);
+    ext_grs_edge_t *e_e689 = ext_grs_act_add_edge(pattern, "e689", ext_grs_NO_EDGE_POS, n_Sub3147, n_Phi3185, 317);
+    ext_grs_edge_t *e_pos1_405 = ext_grs_act_add_edge(pattern, "pos1_405", 0, n_Cond3179, n_Proj3180, 318);
+    ext_grs_edge_t *e_e688 = ext_grs_act_add_edge(pattern, "e688", ext_grs_NO_EDGE_POS, n_Sub3121, n_Phi3185, 319);
+    ext_grs_edge_t *e_e541 = ext_grs_act_add_edge(pattern, "e541", ext_grs_NO_EDGE_POS, n_Add3066, n_Add3153, 320);
+    ext_grs_edge_t *e_e687 = ext_grs_act_add_edge(pattern, "e687", ext_grs_NO_EDGE_POS, n_Block3099, n_Phi3185, 321);
+    ext_grs_edge_t *e_e540 = ext_grs_act_add_edge(pattern, "e540", ext_grs_NO_EDGE_POS, n_Phi3185, n_Add3153, 322);
+    ext_grs_edge_t *e_pos0_735 = ext_grs_act_add_edge(pattern, "pos0_735", -1, n_Block3590, n_Sub3669, 323);
+    ext_grs_edge_t *e_e686 = ext_grs_act_add_edge(pattern, "e686", ext_grs_NO_EDGE_POS, n_Proj3615, n_Block3590, 324);
+    ext_grs_edge_t *e_pos1_328 = ext_grs_act_add_edge(pattern, "pos1_328", 0, n_Arg_0, n_VProj3600, 325);
+    ext_grs_edge_t *e_pos1_329 = ext_grs_act_add_edge(pattern, "pos1_329", 0, n_Arg_0, n_VProj3078, 326);
+    ext_grs_edge_t *e_pos0_731 = ext_grs_act_add_edge(pattern, "pos0_731", -1, n_Block2980, n_Jmp3035, 327);
+    ext_grs_edge_t *e_pos1_602 = ext_grs_act_add_edge(pattern, "pos1_602", 0, n_Conv3688, n_Sub3730, 328);
+    ext_grs_edge_t *e_pos0_330 = ext_grs_act_add_edge(pattern, "pos0_330", -1, n_Block3708, n_Add3675, 329);
+    ext_grs_edge_t *e_pos1_314 = ext_grs_act_add_edge(pattern, "pos1_314", 0, n_Conv2992, n_Cmp5652, 330);
+    ext_grs_edge_t *e_pos0_749 = ext_grs_act_add_edge(pattern, "pos0_749", -1, n_Block2404, n_Cond2483, 331);
+    ext_grs_edge_t *e_e408 = ext_grs_act_add_edge(pattern, "e408", ext_grs_NO_EDGE_POS, n_Add3414, n_Add3501, 332);
+    ext_grs_edge_t *e_e409 = ext_grs_act_add_edge(pattern, "e409", ext_grs_NO_EDGE_POS, n_Proj3528, n_Block3503, 333);
+    ext_grs_edge_t *e_pos0_649 = ext_grs_act_add_edge(pattern, "pos0_649", -1, n_Block2546, n_Jmp2626, 334);
+    ext_grs_edge_t *e_pos0_648 = ext_grs_act_add_edge(pattern, "pos0_648", -1, n_Block2376, n_Jmp2427, 335);
+    ext_grs_edge_t *e_pos0_335 = ext_grs_act_add_edge(pattern, "pos0_335", -1, n_Block2720, n_Sub2799, 336);
+    ext_grs_edge_t *e_e690 = ext_grs_act_add_edge(pattern, "e690", ext_grs_NO_EDGE_POS, n_Proj2746, n_Block2719, 337);
+    ext_grs_edge_t *e_e400 = ext_grs_act_add_edge(pattern, "e400", ext_grs_NO_EDGE_POS, n_Proj3094, n_Block3067, 338);
+    ext_grs_edge_t *e_e692 = ext_grs_act_add_edge(pattern, "e692", ext_grs_NO_EDGE_POS, n_Sub3469, n_Phi3533, 339);
+    ext_grs_edge_t *e_e403 = ext_grs_act_add_edge(pattern, "e403", ext_grs_NO_EDGE_POS, n_Jmp2687, n_Block2664, 340);
+    ext_grs_edge_t *e_e691 = ext_grs_act_add_edge(pattern, "e691", ext_grs_NO_EDGE_POS, n_Block3447, n_Phi3533, 341);
+    ext_grs_edge_t *e_e555 = ext_grs_act_add_edge(pattern, "e555", ext_grs_NO_EDGE_POS, n_Block2664, n_Phi2750, 342);
+    ext_grs_edge_t *e_e693 = ext_grs_act_add_edge(pattern, "e693", ext_grs_NO_EDGE_POS, n_Sub3495, n_Phi3533, 343);
+    ext_grs_edge_t *e_e404 = ext_grs_act_add_edge(pattern, "e404", ext_grs_NO_EDGE_POS, n_Jmp2713, n_Block2664, 344);
+    ext_grs_edge_t *e_e557 = ext_grs_act_add_edge(pattern, "e557", ext_grs_NO_EDGE_POS, n_Sub2712, n_Phi2750, 345);
+    ext_grs_edge_t *e_e407 = ext_grs_act_add_edge(pattern, "e407", ext_grs_NO_EDGE_POS, n_Phi3533, n_Add3501, 346);
+    ext_grs_edge_t *e_e556 = ext_grs_act_add_edge(pattern, "e556", ext_grs_NO_EDGE_POS, n_Sub2686, n_Phi2750, 347);
+    ext_grs_edge_t *e_e698 = ext_grs_act_add_edge(pattern, "e698", ext_grs_NO_EDGE_POS, n_Proj3006, n_Block2981, 348);
+    ext_grs_edge_t *e_pos0_743 = ext_grs_act_add_edge(pattern, "pos0_743", -1, n_Block3242, n_Sub3321, 349);
+    ext_grs_edge_t *e_e553 = ext_grs_act_add_edge(pattern, "e553", ext_grs_NO_EDGE_POS, n_Jmp3322, n_Block3273, 350);
+    ext_grs_edge_t *e_e699 = ext_grs_act_add_edge(pattern, "e699", ext_grs_NO_EDGE_POS, n_Block3621, n_Phi3707, 351);
+    ext_grs_edge_t *e_e552 = ext_grs_act_add_edge(pattern, "e552", ext_grs_NO_EDGE_POS, n_Jmp3296, n_Block3273, 352);
+    ext_grs_edge_t *e_pos1_319 = ext_grs_act_add_edge(pattern, "pos1_319", 0, n_Cmp5646, n_Proj2482, 353);
+    ext_grs_edge_t *e_pos1_317 = ext_grs_act_add_edge(pattern, "pos1_317", 0, n_Proj2830, n_Cond2831, 354);
+    ext_grs_edge_t *e_pos1_318 = ext_grs_act_add_edge(pattern, "pos1_318", 0, n_VProj2740, n_Conv2741, 355);
+    ext_grs_edge_t *e_pos0_722 = ext_grs_act_add_edge(pattern, "pos0_722", -1, n_Block2458, n_Jmp2513, 356);
+    ext_grs_edge_t *e_pos1_695 = ext_grs_act_add_edge(pattern, "pos1_695", 0, n_Conv2470, n_Sub2512, 357);
+    ext_grs_edge_t *e_pos1_417 = ext_grs_act_add_edge(pattern, "pos1_417", 0, n_Cond3440, n_Proj3442, 358);
+    ext_grs_edge_t *e_pos1_416 = ext_grs_act_add_edge(pattern, "pos1_416", 0, n_Cmp5647, n_Proj2569, 359);
+    ext_grs_edge_t *e_pos1_697 = ext_grs_act_add_edge(pattern, "pos1_697", 0, n_Arg_0, n_VProj2469, 360);
+    ext_grs_edge_t *e_pos0_723 = ext_grs_act_add_edge(pattern, "pos0_723", -1, n_Block3068, n_Sub3147, 361);
+    ext_grs_edge_t *e_pos1_559 = ext_grs_act_add_edge(pattern, "pos1_559", 0, n_Cond2657, n_Proj2658, 362);
+    ext_grs_edge_t *e_pos1_558 = ext_grs_act_add_edge(pattern, "pos1_558", 0, n_Cond2657, n_Proj2659, 363);
+    ext_grs_edge_t *e_pos1_551 = ext_grs_act_add_edge(pattern, "pos1_551", 0, n_Cmp5645, n_Proj2397, 364);
+    ext_grs_edge_t *e_pos1_554 = ext_grs_act_add_edge(pattern, "pos1_554", 0, n_VProj3523, n_Conv3524, 365);
+    ext_grs_edge_t *e_pos1_410 = ext_grs_act_add_edge(pattern, "pos1_410", 0, n_VProj2817, n_Conv2818, 366);
+    ext_grs_edge_t *e_pos1_550 = ext_grs_act_add_edge(pattern, "pos1_550", 0, n_Arg_0, n_VProj2904, 367);
+    ext_grs_edge_t *e_pos1_411 = ext_grs_act_add_edge(pattern, "pos1_411", 0, n_Conv3253, n_Cmp5655, 368);
+    ext_grs_edge_t *e_pos0_726 = ext_grs_act_add_edge(pattern, "pos0_726", -1, n_Block3416, n_Sub3495, 369);
+    ext_grs_edge_t *e_pos1_413 = ext_grs_act_add_edge(pattern, "pos1_413", 0, n_VProj2827, n_Conv2828, 370);
+    ext_grs_edge_t *e_pos1_414 = ext_grs_act_add_edge(pattern, "pos1_414", 0, n_Arg_1, n_VProj2479, 371);
+    ext_grs_edge_t *e_pos1_415 = ext_grs_act_add_edge(pattern, "pos1_415", 0, n_Cmp5654, n_Proj3178, 372);
+    ext_grs_edge_t *e_pos1_569 = ext_grs_act_add_edge(pattern, "pos1_569", 0, n_Conv3688, n_Cmp5660, 373);
+    ext_grs_edge_t *e_pos1_567 = ext_grs_act_add_edge(pattern, "pos1_567", 0, n_Cond2831, n_Proj2833, 374);
+    ext_grs_edge_t *e_pos1_561 = ext_grs_act_add_edge(pattern, "pos1_561", 0, n_Proj3352, n_Cond3353, 375);
+    ext_grs_edge_t *e_pos1_422 = ext_grs_act_add_edge(pattern, "pos1_422", 0, n_Cmp5659, n_Proj3613, 376);
+    ext_grs_edge_t *e_pos1_425 = ext_grs_act_add_edge(pattern, "pos1_425", 0, n_Arg_0, n_VProj2643, 377);
+    ext_grs_edge_t *e_pos1_423 = ext_grs_act_add_edge(pattern, "pos1_423", 0, n_Cmp5653, n_Proj3091, 378);
+    ext_grs_edge_t *e_pos1_438 = ext_grs_act_add_edge(pattern, "pos1_438", 0, n_Cond3179, n_Proj3181, 379);
+    ext_grs_edge_t *e_pos0_601 = ext_grs_act_add_edge(pattern, "pos0_601", -1, n_Block3676, n_Sub3730, 380);
+    ext_grs_edge_t *e_pos1_537 = ext_grs_act_add_edge(pattern, "pos1_537", 0, n_Conv2828, n_Sub2886, 381);
+    ext_grs_edge_t *e_pos1_530 = ext_grs_act_add_edge(pattern, "pos1_530", 0, n_Cmp5660, n_Proj3700, 382);
+    ext_grs_edge_t *e_pos1_531 = ext_grs_act_add_edge(pattern, "pos1_531", 0, n_Cond3266, n_Proj3268, 383);
+    ext_grs_edge_t *e_pos1_533 = ext_grs_act_add_edge(pattern, "pos1_533", 0, n_Conv3524, n_Sub3582, 384);
+    ext_grs_edge_t *e_pos0_607 = ext_grs_act_add_edge(pattern, "pos0_607", -1, n_Block2980, n_Sub3034, 385);
+    ext_grs_edge_t *e_pos1_435 = ext_grs_act_add_edge(pattern, "pos1_435", 0, n_Conv3340, n_Cmp5656, 386);
+    ext_grs_edge_t *e_pos1_437 = ext_grs_act_add_edge(pattern, "pos1_437", 0, n_Arg_1, n_VProj2827, 387);
+    ext_grs_edge_t *e_pos0_707 = ext_grs_act_add_edge(pattern, "pos0_707", -1, n_Block3708, n_Add2631, 388);
+    ext_grs_edge_t *e_pos1_432 = ext_grs_act_add_edge(pattern, "pos1_432", 0, n_Arg_0, n_VProj2817, 389);
+    ext_grs_edge_t *e_pos1_548 = ext_grs_act_add_edge(pattern, "pos1_548", 0, n_Conv3601, n_Cmp5659, 390);
+    ext_grs_edge_t *e_pos1_440 = ext_grs_act_add_edge(pattern, "pos1_440", 0, n_Proj3526, n_Cond3527, 391);
+    ext_grs_edge_t *e_pos1_547 = ext_grs_act_add_edge(pattern, "pos1_547", 0, n_Arg_0, n_VProj3687, 392);
+    ext_grs_edge_t *e_pos1_544 = ext_grs_act_add_edge(pattern, "pos1_544", 0, n_Conv3176, n_Sub3234, 393);
+    ext_grs_edge_t *e_pos1_447 = ext_grs_act_add_edge(pattern, "pos1_447", 0, n_Cond3614, n_Proj3616, 394);
+    ext_grs_edge_t *e_pos1_445 = ext_grs_act_add_edge(pattern, "pos1_445", 0, n_Conv2557, n_Sub2599, 395);
+    ext_grs_edge_t *e_pos1_443 = ext_grs_act_add_edge(pattern, "pos1_443", 0, n_Cond2570, n_Proj2572, 396);
+    ext_grs_edge_t *e_pos1_441 = ext_grs_act_add_edge(pattern, "pos1_441", 0, n_VProj2385, n_Conv2386, 397);
+    ext_grs_edge_t *e_pos1_650 = ext_grs_act_add_edge(pattern, "pos1_650", 0, n_Cond3440, n_Proj3441, 398);
+    ext_grs_edge_t *e_pos1_652 = ext_grs_act_add_edge(pattern, "pos1_652", 0, n_Proj3439, n_Cond3440, 399);
+    ext_grs_edge_t *e_pos1_653 = ext_grs_act_add_edge(pattern, "pos1_653", 0, n_VProj3349, n_Conv3350, 400);
+    ext_grs_edge_t *e_pos1_654 = ext_grs_act_add_edge(pattern, "pos1_654", 0, n_Cond3701, n_Proj3703, 401);
+    ext_grs_edge_t *e_pos1_659 = ext_grs_act_add_edge(pattern, "pos1_659", 0, n_Cond2831, n_Proj2832, 402);
+    ext_grs_edge_t *e_pos1_658 = ext_grs_act_add_edge(pattern, "pos1_658", 0, n_Cond2918, n_Proj2920, 403);
+    ext_grs_edge_t *e_pos1_591 = ext_grs_act_add_edge(pattern, "pos1_591", 0, n_Conv2654, n_Sub2712, 404);
+    ext_grs_edge_t *e_pos1_593 = ext_grs_act_add_edge(pattern, "pos1_593", 0, n_Cond2483, n_Proj2484, 405);
+    ext_grs_edge_t *e_pos1_458 = ext_grs_act_add_edge(pattern, "pos1_458", 0, n_VProj3339, n_Conv3340, 406);
+    ext_grs_edge_t *e_pos1_598 = ext_grs_act_add_edge(pattern, "pos1_598", 0, n_Proj2917, n_Cond2918, 407);
+    ext_grs_edge_t *e_pos1_451 = ext_grs_act_add_edge(pattern, "pos1_451", 0, n_Cond3527, n_Proj3528, 408);
+    ext_grs_edge_t *e_pos1_660 = ext_grs_act_add_edge(pattern, "pos1_660", 0, n_Conv2644, n_Cmp5648, 409);
+    ext_grs_edge_t *e_pos1_668 = ext_grs_act_add_edge(pattern, "pos1_668", 0, n_Arg_1, n_VProj3349, 410);
+    ext_grs_edge_t *e_pos1_665 = ext_grs_act_add_edge(pattern, "pos1_665", 0, n_VProj2469, n_Conv2470, 411);
+    ext_grs_edge_t *e_pos1_466 = ext_grs_act_add_edge(pattern, "pos1_466", 0, n_Conv3427, n_Cmp5657, 412);
+    ext_grs_edge_t *e_pos1_669 = ext_grs_act_add_edge(pattern, "pos1_669", 0, n_Cmp5657, n_Proj3439, 413);
+    ext_grs_edge_t *e_pos1_469 = ext_grs_act_add_edge(pattern, "pos1_469", 0, n_Conv2386, n_Sub2426, 414);
+    ext_grs_edge_t *e_pos1_670 = ext_grs_act_add_edge(pattern, "pos1_670", 0, n_VProj2991, n_Conv2992, 415);
+    ext_grs_edge_t *e_pos1_679 = ext_grs_act_add_edge(pattern, "pos1_679", 0, n_Proj3004, n_Cond3005, 416);
+    ext_grs_edge_t *e_pos1_673 = ext_grs_act_add_edge(pattern, "pos1_673", 0, n_Conv2644, n_Sub2686, 417);
+    ext_grs_edge_t *e_pos0_292 = ext_grs_act_add_edge(pattern, "pos0_292", -1, n_Vector_op_Block, n_Proj2399, 418);
+    ext_grs_edge_t *e_pos1_475 = ext_grs_act_add_edge(pattern, "pos1_475", 0, n_Cond2918, n_Proj2919, 419);
+    ext_grs_edge_t *e_pos1_474 = ext_grs_act_add_edge(pattern, "pos1_474", 0, n_VProj2566, n_Conv2567, 420);
+    ext_grs_edge_t *e_pos1_476 = ext_grs_act_add_edge(pattern, "pos1_476", 0, n_Arg_1, n_VProj3436, 421);
+    ext_grs_edge_t *e_pos1_473 = ext_grs_act_add_edge(pattern, "pos1_473", 0, n_VProj3175, n_Conv3176, 422);
+    ext_grs_edge_t *e_pos1_575 = ext_grs_act_add_edge(pattern, "pos1_575", 0, n_Conv2386, n_Cmp5645, 423);
+    ext_grs_edge_t *e_pos1_472 = ext_grs_act_add_edge(pattern, "pos1_472", 0, n_Proj3265, n_Cond3266, 424);
+    ext_grs_edge_t *e_pos1_578 = ext_grs_act_add_edge(pattern, "pos1_578", 0, n_VProj3262, n_Conv3263, 425);
+    ext_grs_edge_t *e_pos1_579 = ext_grs_act_add_edge(pattern, "pos1_579", 0, n_Cond3701, n_Proj3702, 426);
+    ext_grs_edge_t *e_pos1_680 = ext_grs_act_add_edge(pattern, "pos1_680", 0, n_VProj2914, n_Conv2915, 427);
+    ext_grs_edge_t *e_pos1_683 = ext_grs_act_add_edge(pattern, "pos1_683", 0, n_Cond3266, n_Proj3267, 428);
+    ext_grs_edge_t *e_pos1_684 = ext_grs_act_add_edge(pattern, "pos1_684", 0, n_Conv2731, n_Cmp5649, 429);
+    ext_grs_edge_t *e_pos1_583 = ext_grs_act_add_edge(pattern, "pos1_583", 0, n_VProj2653, n_Conv2654, 430);
+    ext_grs_edge_t *e_pos1_582 = ext_grs_act_add_edge(pattern, "pos1_582", 0, n_Proj2743, n_Cond2744, 431);
+    ext_grs_edge_t *e_pos1_487 = ext_grs_act_add_edge(pattern, "pos1_487", 0, n_VProj3088, n_Conv3089, 432);
+    ext_grs_edge_t *e_pos1_486 = ext_grs_act_add_edge(pattern, "pos1_486", 0, n_VProj3610, n_Conv3611, 433);
+    ext_grs_edge_t *e_pos1_580 = ext_grs_act_add_edge(pattern, "pos1_580", 0, n_Arg_1, n_VProj3523, 434);
+    ext_grs_edge_t *e_pos1_485 = ext_grs_act_add_edge(pattern, "pos1_485", 0, n_Proj3700, n_Cond3701, 435);
+    ext_grs_edge_t *e_pos1_587 = ext_grs_act_add_edge(pattern, "pos1_587", 0, n_VProj3697, n_Conv3698, 436);
+    ext_grs_edge_t *e_pos1_586 = ext_grs_act_add_edge(pattern, "pos1_586", 0, n_Cond3092, n_Proj3093, 437);
+    ext_grs_edge_t *e_pos1_482 = ext_grs_act_add_edge(pattern, "pos1_482", 0, n_Proj2656, n_Cond2657, 438);
+    ext_grs_edge_t *e_pos1_480 = ext_grs_act_add_edge(pattern, "pos1_480", 0, n_Cmp5658, n_Proj3526, 439);
+    ext_grs_edge_t *e_pos1_588 = ext_grs_act_add_edge(pattern, "pos1_588", 0, n_Cmp5656, n_Proj3352, 440);
+    ext_grs_edge_t *e_e290 = ext_grs_act_add_edge(pattern, "e290", ext_grs_NO_EDGE_POS, n_Proj2485, n_Block2458, 441);
+    ext_grs_edge_t *e_e382 = ext_grs_act_add_edge(pattern, "e382", ext_grs_NO_EDGE_POS, n_Proj3181, n_Block3154, 442);
+    ext_grs_edge_t *e_pos2_696 = ext_grs_act_add_edge(pattern, "pos2_696", 1, n_Conv2480, n_Sub2512, 443);
+    ext_grs_edge_t *e_pos2_508 = ext_grs_act_add_edge(pattern, "pos2_508", 1, n_Conv3688, n_Sub3756, 444);
+    ext_grs_edge_t *e_e395 = ext_grs_act_add_edge(pattern, "e395", ext_grs_NO_EDGE_POS, n_Proj2572, n_Block2545, 445);
+    ext_grs_edge_t *e_e399 = ext_grs_act_add_edge(pattern, "e399", ext_grs_NO_EDGE_POS, n_Proj3616, n_Block3589, 446);
+    ext_grs_edge_t *e_e299 = ext_grs_act_add_edge(pattern, "e299", ext_grs_NO_EDGE_POS, n_Sub2773, n_Phi2837, 447);
+    ext_grs_edge_t *e_e298 = ext_grs_act_add_edge(pattern, "e298", ext_grs_NO_EDGE_POS, n_Block2751, n_Phi2837, 448);
+    ext_grs_edge_t *e_e295 = ext_grs_act_add_edge(pattern, "e295", ext_grs_NO_EDGE_POS, n_Proj3529, n_Block3502, 449);
+    ext_grs_edge_t *e_e296 = ext_grs_act_add_edge(pattern, "e296", ext_grs_NO_EDGE_POS, n_Proj3007, n_Block2980, 450);
+    ext_grs_edge_t *e_pos2_516 = ext_grs_act_add_edge(pattern, "pos2_516", 1, n_Conv2992, n_Sub3060, 451);
+    ext_grs_edge_t *e_pos2_315 = ext_grs_act_add_edge(pattern, "pos2_315", 1, n_Conv3002, n_Cmp5652, 452);
+    ext_grs_edge_t *e_pos2_510 = ext_grs_act_add_edge(pattern, "pos2_510", 1, n_Conv3524, n_Cmp5658, 453);
+    ext_grs_edge_t *e_pos2_521 = ext_grs_act_add_edge(pattern, "pos2_521", 1, n_Conv3340, n_Sub3408, 454);
+    ext_grs_edge_t *e_pos2_538 = ext_grs_act_add_edge(pattern, "pos2_538", 1, n_Conv2818, n_Sub2886, 455);
+    ext_grs_edge_t *e_pos2_436 = ext_grs_act_add_edge(pattern, "pos2_436", 1, n_Conv3350, n_Cmp5656, 456);
+    ext_grs_edge_t *e_pos2_534 = ext_grs_act_add_edge(pattern, "pos2_534", 1, n_Conv3514, n_Sub3582, 457);
+    ext_grs_edge_t *e_pos2_549 = ext_grs_act_add_edge(pattern, "pos2_549", 1, n_Conv3611, n_Cmp5659, 458);
+    ext_grs_edge_t *e_pos2_446 = ext_grs_act_add_edge(pattern, "pos2_446", 1, n_Conv2567, n_Sub2599, 459);
+    ext_grs_edge_t *e_pos2_545 = ext_grs_act_add_edge(pattern, "pos2_545", 1, n_Conv3166, n_Sub3234, 460);
+    ext_grs_edge_t *e_pos2_412 = ext_grs_act_add_edge(pattern, "pos2_412", 1, n_Conv3263, n_Cmp5655, 461);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2399};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42812, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3426};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42815, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e681, e_e299};
+
+      ext_grs_act_register_condition(grs_cond_func_42818, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e682, e_e300};
+
+      ext_grs_act_register_condition(grs_cond_func_42821, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e304, e_e631};
+
+      ext_grs_act_register_condition(grs_cond_func_42824, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e305, e_e632};
+
+      ext_grs_act_register_condition(grs_cond_func_42827, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2482};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42830, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e584, e_e321};
+
+      ext_grs_act_register_condition(grs_cond_func_42833, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e585, e_e322};
+
+      ext_grs_act_register_condition(grs_cond_func_42836, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3165};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42839, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2556};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42842, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3078};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42845, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3600};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42848, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3001};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42851, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2740};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42854, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2830};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42857, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2485};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42860, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3094};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42863, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3007};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42866, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3529};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42869, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2745};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42872, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3513};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42875, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3180};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42878, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3252};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42881, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2479};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42884, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2569};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42887, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3178};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42890, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3442};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42893, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3091};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42896, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3613};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42899, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2643};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42902, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2817};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42905, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2827};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42908, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3181};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42911, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2572};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42914, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3616};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42917, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3528};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42920, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e420, e_e453};
+
+      ext_grs_act_register_condition(grs_cond_func_42923, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e421, e_e454};
+
+      ext_grs_act_register_condition(grs_cond_func_42926, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e624, e_e460};
+
+      ext_grs_act_register_condition(grs_cond_func_42929, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e625, e_e461};
+
+      ext_grs_act_register_condition(grs_cond_func_42932, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e351, e_e464};
+
+      ext_grs_act_register_condition(grs_cond_func_42935, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e352, e_e465};
+
+      ext_grs_act_register_condition(grs_cond_func_42938, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2919};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42941, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3436};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42944, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3526};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42947, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e312, e_e478};
+
+      ext_grs_act_register_condition(grs_cond_func_42950, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e313, e_e479};
+
+      ext_grs_act_register_condition(grs_cond_func_42953, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e489, e_e523};
+
+      ext_grs_act_register_condition(grs_cond_func_42956, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e490, e_e524};
+
+      ext_grs_act_register_condition(grs_cond_func_42959, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e715, e_e492};
+
+      ext_grs_act_register_condition(grs_cond_func_42962, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e493, e_e716};
+
+      ext_grs_act_register_condition(grs_cond_func_42965, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3339};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42968, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2566};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42971, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3175};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42974, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3354};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42977, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3265};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42980, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2656};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42983, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3088};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42986, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3610};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42989, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3268};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42992, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3700};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42995, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3687};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_42998, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2904};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43001, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2397};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43004, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2658};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43007, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2659};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43010, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e403, e_e556};
+
+      ext_grs_act_register_condition(grs_cond_func_43013, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e404, e_e557};
+
+      ext_grs_act_register_condition(grs_cond_func_43016, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2833};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43019, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e433, e_e573};
+
+      ext_grs_act_register_condition(grs_cond_func_43022, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e434, e_e574};
+
+      ext_grs_act_register_condition(grs_cond_func_43025, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3702};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43028, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3523};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43031, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3093};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43034, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3352};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43037, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2484};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43040, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3262};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43043, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2385};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43046, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2653};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43049, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3697};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43052, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3355};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43055, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2917};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43058, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2394};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43061, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2730};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43064, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3441};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43067, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3703};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43070, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2920};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43073, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2832};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43076, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3349};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43079, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3439};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43082, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3267};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43085, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e688, e_e427};
+
+      ext_grs_act_register_condition(grs_cond_func_43088, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e428, e_e689};
+
+      ext_grs_act_register_condition(grs_cond_func_43091, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e692, e_e497};
+
+      ext_grs_act_register_condition(grs_cond_func_43094, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e693, e_e498};
+
+      ext_grs_act_register_condition(grs_cond_func_43097, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2469};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43100, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e617, e_e700};
+
+      ext_grs_act_register_condition(grs_cond_func_43103, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e701, e_e618};
+
+      ext_grs_act_register_condition(grs_cond_func_43106, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2991};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43109, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e325, e_e705};
+
+      ext_grs_act_register_condition(grs_cond_func_43112, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e326, e_e706};
+
+      ext_grs_act_register_condition(grs_cond_func_43115, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj2914};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43118, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e711, e_e552};
+
+      ext_grs_act_register_condition(grs_cond_func_43121, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t **nodes = NULL;
+      ext_grs_edge_t *edges[2] = {e_e712, e_e553};
+
+      ext_grs_act_register_condition(grs_cond_func_43124, pattern, 0, nodes, 2, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3004};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43127, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2743};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43130, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2400};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43133, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2571};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43136, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3615};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43139, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj2746};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43142, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3006};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_43145, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Proj3178_430 = ext_grs_act_add_node_to_keep(pattern, "Proj3178_430", grs_op_Proj, mode_b, 0, n_Proj3178);
+       ext_grs_node_t *n_Sub3234_431 = ext_grs_act_add_node_to_keep(pattern, "Sub3234_431", grs_op_Sub, mode_Is, 1, n_Sub3234);
+       ext_grs_node_t *n_Sub3556_432 = ext_grs_act_add_node_to_keep(pattern, "Sub3556_432", grs_op_Sub, mode_Is, 2, n_Sub3556);
+       ext_grs_node_t *n_Phi3620_433 = ext_grs_act_add_node_to_keep(pattern, "Phi3620_433", grs_op_Phi, mode_Is, 3, n_Phi3620);
+       ext_grs_node_t *n_Sub2886_434 = ext_grs_act_add_node_to_keep(pattern, "Sub2886_434", grs_op_Sub, mode_Is, 5, n_Sub2886);
+       ext_grs_node_t *n_Block3329_435 = ext_grs_act_add_node_to_keep(pattern, "Block3329_435", grs_op_Block, mode_BB, 4, n_Block3329);
+       ext_grs_node_t *n_Block3328_436 = ext_grs_act_add_node_to_keep(pattern, "Block3328_436", grs_op_Block, mode_BB, 8, n_Block3328);
+       ext_grs_node_t *n_Conv2818_437 = ext_grs_act_add_node_to_keep(pattern, "Conv2818_437", grs_op_Conv, mode_Is, 7, n_Conv2818);
+       ext_grs_node_t *n_VProj2385_438 = ext_grs_act_add_node_to_keep(pattern, "VProj2385_438", grs_op_VProj, mode_Bu, 6, n_VProj2385);
+       ext_grs_node_t *n_Conv2915_439 = ext_grs_act_add_node_to_keep(pattern, "Conv2915_439", grs_op_Conv, mode_Is, 9, n_Conv2915);
+       ext_grs_node_t *n_VProj2991_440 = ext_grs_act_add_node_to_keep(pattern, "VProj2991_440", grs_op_VProj, mode_Bu, 10, n_VProj2991);
+       ext_grs_node_t *n_Cond3527_441 = ext_grs_act_add_node_to_keep(pattern, "Cond3527_441", grs_op_Cond, mode_T, 11, n_Cond3527);
+       ext_grs_node_t *n_Jmp2948_442 = ext_grs_act_add_node_to_keep(pattern, "Jmp2948_442", grs_op_Jmp, mode_X, 12, n_Jmp2948);
+       ext_grs_node_t *n_Proj3439_443 = ext_grs_act_add_node_to_keep(pattern, "Proj3439_443", grs_op_Proj, mode_b, 13, n_Proj3439);
+       ext_grs_node_t *n_Sub3034_444 = ext_grs_act_add_node_to_keep(pattern, "Sub3034_444", grs_op_Sub, mode_Is, 14, n_Sub3034);
+       ext_grs_node_t *n_Sub3756_445 = ext_grs_act_add_node_to_keep(pattern, "Sub3756_445", grs_op_Sub, mode_Is, 16, n_Sub3756);
+       ext_grs_node_t *n_Sub2686_446 = ext_grs_act_add_node_to_keep(pattern, "Sub2686_446", grs_op_Sub, mode_Is, 15, n_Sub2686);
+       ext_grs_node_t *n_VProj2653_447 = ext_grs_act_add_node_to_keep(pattern, "VProj2653_447", grs_op_VProj, mode_Bu, 17, n_VProj2653);
+       ext_grs_node_t *n_Jmp3061_448 = ext_grs_act_add_node_to_keep(pattern, "Jmp3061_448", grs_op_Jmp, mode_X, 18, n_Jmp3061);
+       ext_grs_node_t *n_Conv2828_449 = ext_grs_act_add_node_to_keep(pattern, "Conv2828_449", grs_op_Conv, mode_Is, 19, n_Conv2828);
+       ext_grs_node_t *n_Jmp2539_450 = ext_grs_act_add_node_to_keep(pattern, "Jmp2539_450", grs_op_Jmp, mode_X, 20, n_Jmp2539);
+       ext_grs_node_t *n_VProj2394_451 = ext_grs_act_add_node_to_keep(pattern, "VProj2394_451", grs_op_VProj, mode_Bu, 21, n_VProj2394);
+       ext_grs_node_t *n_Sub3321_452 = ext_grs_act_add_node_to_keep(pattern, "Sub3321_452", grs_op_Sub, mode_Is, 22, n_Sub3321);
+       ext_grs_node_t *n_Sub3643_453 = ext_grs_act_add_node_to_keep(pattern, "Sub3643_453", grs_op_Sub, mode_Is, 23, n_Sub3643);
+       ext_grs_node_t *n_Conv3089_454 = ext_grs_act_add_node_to_keep(pattern, "Conv3089_454", grs_op_Conv, mode_Is, 24, n_Conv3089);
+       ext_grs_node_t *n_Sub3121_455 = ext_grs_act_add_node_to_keep(pattern, "Sub3121_455", grs_op_Sub, mode_Is, 25, n_Sub3121);
+       ext_grs_node_t *n_Phi3707_456 = ext_grs_act_add_node_to_keep(pattern, "Phi3707_456", grs_op_Phi, mode_Is, 26, n_Phi3707);
+       ext_grs_node_t *n_Proj3441_457 = ext_grs_act_add_node_to_keep(pattern, "Proj3441_457", grs_op_Proj, mode_X, 27, n_Proj3441);
+       ext_grs_node_t *n_Proj3442_458 = ext_grs_act_add_node_to_keep(pattern, "Proj3442_458", grs_op_Proj, mode_X, 28, n_Proj3442);
+       ext_grs_node_t *n_Cond3440_459 = ext_grs_act_add_node_to_keep(pattern, "Cond3440_459", grs_op_Cond, mode_T, 29, n_Cond3440);
+       ext_grs_node_t *n_Proj3180_460 = ext_grs_act_add_node_to_keep(pattern, "Proj3180_460", grs_op_Proj, mode_X, 30, n_Proj3180);
+       ext_grs_node_t *n_Proj3181_461 = ext_grs_act_add_node_to_keep(pattern, "Proj3181_461", grs_op_Proj, mode_X, 31, n_Proj3181);
+       ext_grs_node_t *n_VProj2643_462 = ext_grs_act_add_node_to_keep(pattern, "VProj2643_462", grs_op_VProj, mode_Bu, 32, n_VProj2643);
+       ext_grs_node_t *n_VProj3349_463 = ext_grs_act_add_node_to_keep(pattern, "VProj3349_463", grs_op_VProj, mode_Bu, 33, n_VProj3349);
+       ext_grs_node_t *n_Jmp2626_464 = ext_grs_act_add_node_to_keep(pattern, "Jmp2626_464", grs_op_Jmp, mode_X, 34, n_Jmp2626);
+       ext_grs_node_t *n_VProj3513_465 = ext_grs_act_add_node_to_keep(pattern, "VProj3513_465", grs_op_VProj, mode_Bu, 35, n_VProj3513);
+       ext_grs_node_t *n_Jmp3322_466 = ext_grs_act_add_node_to_keep(pattern, "Jmp3322_466", grs_op_Jmp, mode_X, 36, n_Jmp3322);
+       ext_grs_node_t *n_Phi2489_467 = ext_grs_act_add_node_to_keep(pattern, "Phi2489_467", grs_op_Phi, mode_Is, 37, n_Phi2489);
+       ext_grs_node_t *n_Proj3703_468 = ext_grs_act_add_node_to_keep(pattern, "Proj3703_468", grs_op_Proj, mode_X, 38, n_Proj3703);
+       ext_grs_node_t *n_Proj3702_469 = ext_grs_act_add_node_to_keep(pattern, "Proj3702_469", grs_op_Proj, mode_X, 39, n_Proj3702);
+       ext_grs_node_t *n_Jmp2427_470 = ext_grs_act_add_node_to_keep(pattern, "Jmp2427_470", grs_op_Jmp, mode_X, 40, n_Jmp2427);
+       ext_grs_node_t *n_VProj3610_471 = ext_grs_act_add_node_to_keep(pattern, "VProj3610_471", grs_op_VProj, mode_Bu, 42, n_VProj3610);
+       ext_grs_node_t *n_Block3099_472 = ext_grs_act_add_node_to_keep(pattern, "Block3099_472", grs_op_Block, mode_BB, 41, n_Block3099);
+       ext_grs_node_t *n_Proj3700_473 = ext_grs_act_add_node_to_keep(pattern, "Proj3700_473", grs_op_Proj, mode_b, 43, n_Proj3700);
+       ext_grs_node_t *n_VProj2469_474 = ext_grs_act_add_node_to_keep(pattern, "VProj2469_474", grs_op_VProj, mode_Bu, 44, n_VProj2469);
+       ext_grs_node_t *n_Conv3688_475 = ext_grs_act_add_node_to_keep(pattern, "Conv3688_475", grs_op_Conv, mode_Is, 45, n_Conv3688);
+       ext_grs_node_t *n_Add2544_476 = ext_grs_act_add_node_to_keep(pattern, "Add2544_476", grs_op_Add, mode_Is, 46, n_Add2544);
+       ext_grs_node_t *n_Sub3730_477 = ext_grs_act_add_node_to_keep(pattern, "Sub3730_477", grs_op_Sub, mode_Is, 47, n_Sub3730);
+       ext_grs_node_t *n_VProj3339_478 = ext_grs_act_add_node_to_keep(pattern, "VProj3339_478", grs_op_VProj, mode_Bu, 49, n_VProj3339);
+       ext_grs_node_t *n_Jmp3035_479 = ext_grs_act_add_node_to_keep(pattern, "Jmp3035_479", grs_op_Jmp, mode_X, 48, n_Jmp3035);
+       ext_grs_node_t *n_VProj2566_480 = ext_grs_act_add_node_to_keep(pattern, "VProj2566_480", grs_op_VProj, mode_Bu, 50, n_VProj2566);
+       ext_grs_node_t *n_VProj3523_481 = ext_grs_act_add_node_to_keep(pattern, "VProj3523_481", grs_op_VProj, mode_Bu, 51, n_VProj3523);
+       ext_grs_node_t *n_Phi3870_482 = ext_grs_act_add_node_to_keep(pattern, "Phi3870_482", grs_op_Phi, mode_Is, 52, n_Phi3870);
+       ext_grs_node_t *n_Conv3698_483 = ext_grs_act_add_node_to_keep(pattern, "Conv3698_483", grs_op_Conv, mode_Is, 53, n_Conv3698);
+       ext_grs_node_t *n_Sub3208_484 = ext_grs_act_add_node_to_keep(pattern, "Sub3208_484", grs_op_Sub, mode_Is, 54, n_Sub3208);
+       ext_grs_node_t *n_Sub3669_485 = ext_grs_act_add_node_to_keep(pattern, "Sub3669_485", grs_op_Sub, mode_Is, 55, n_Sub3669);
+       ext_grs_node_t *n_Proj2832_486 = ext_grs_act_add_node_to_keep(pattern, "Proj2832_486", grs_op_Proj, mode_X, 56, n_Proj2832);
+       ext_grs_node_t *n_Proj2830_487 = ext_grs_act_add_node_to_keep(pattern, "Proj2830_487", grs_op_Proj, mode_b, 59, n_Proj2830);
+       ext_grs_node_t *n_Sub2799_488 = ext_grs_act_add_node_to_keep(pattern, "Sub2799_488", grs_op_Sub, mode_Is, 58, n_Sub2799);
+       ext_grs_node_t *n_VProj2479_489 = ext_grs_act_add_node_to_keep(pattern, "VProj2479_489", grs_op_VProj, mode_Bu, 57, n_VProj2479);
+       ext_grs_node_t *n_Proj2833_490 = ext_grs_act_add_node_to_keep(pattern, "Proj2833_490", grs_op_Proj, mode_X, 60, n_Proj2833);
+       ext_grs_node_t *n_Block3677_491 = ext_grs_act_add_node_to_keep(pattern, "Block3677_491", grs_op_Block, mode_BB, 61, n_Block3677);
+       ext_grs_node_t *n_Block3676_492 = ext_grs_act_add_node_to_keep(pattern, "Block3676_492", grs_op_Block, mode_BB, 63, n_Block3676);
+       ext_grs_node_t *n_Sub3147_493 = ext_grs_act_add_node_to_keep(pattern, "Sub3147_493", grs_op_Sub, mode_Is, 62, n_Sub3147);
+       ext_grs_node_t *n_Phi2750_494 = ext_grs_act_add_node_to_keep(pattern, "Phi2750_494", grs_op_Phi, mode_Is, 64, n_Phi2750);
+       ext_grs_node_t *n_VProj3426_495 = ext_grs_act_add_node_to_keep(pattern, "VProj3426_495", grs_op_VProj, mode_Bu, 66, n_VProj3426);
+       ext_grs_node_t *n_Proj2400_496 = ext_grs_act_add_node_to_keep(pattern, "Proj2400_496", grs_op_Proj, mode_X, 65, n_Proj2400);
+       ext_grs_node_t *n_Phi3098_497 = ext_grs_act_add_node_to_keep(pattern, "Phi3098_497", grs_op_Phi, mode_Is, 67, n_Phi3098);
+       ext_grs_node_t *n_Jmp2600_498 = ext_grs_act_add_node_to_keep(pattern, "Jmp2600_498", grs_op_Jmp, mode_X, 68, n_Jmp2600);
+       ext_grs_node_t *n_Jmp3409_499 = ext_grs_act_add_node_to_keep(pattern, "Jmp3409_499", grs_op_Jmp, mode_X, 69, n_Jmp3409);
+       ext_grs_node_t *n_Jmp2887_500 = ext_grs_act_add_node_to_keep(pattern, "Jmp2887_500", grs_op_Jmp, mode_X, 70, n_Jmp2887);
+       ext_grs_node_t *n_Jmp3209_501 = ext_grs_act_add_node_to_keep(pattern, "Jmp3209_501", grs_op_Jmp, mode_X, 71, n_Jmp3209);
+       ext_grs_node_t *n_Conv3514_502 = ext_grs_act_add_node_to_keep(pattern, "Conv3514_502", grs_op_Conv, mode_Is, 72, n_Conv3514);
+       ext_grs_node_t *n_Block3360_503 = ext_grs_act_add_node_to_keep(pattern, "Block3360_503", grs_op_Block, mode_BB, 74, n_Block3360);
+       ext_grs_node_t *n_Add2979_504 = ext_grs_act_add_node_to_keep(pattern, "Add2979_504", grs_op_Add, mode_Is, 73, n_Add2979);
+       ext_grs_node_t *n_Cond2570_505 = ext_grs_act_add_node_to_keep(pattern, "Cond2570_505", grs_op_Cond, mode_T, 75, n_Cond2570);
+       ext_grs_node_t *n_Block3067_506 = ext_grs_act_add_node_to_keep(pattern, "Block3067_506", grs_op_Block, mode_BB, 76, n_Block3067);
+       ext_grs_node_t *n_Arg_0_507 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_507", grs_op_VectorBase, mode_ANY, 77, n_Arg_0);
+       ext_grs_node_t *n_Block3068_508 = ext_grs_act_add_node_to_keep(pattern, "Block3068_508", grs_op_Block, mode_BB, 79, n_Block3068);
+       ext_grs_node_t *n_Arg_1_509 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_509", grs_op_VectorBase, mode_ANY, 78, n_Arg_1);
+       ext_grs_node_t *n_VProj3600_510 = ext_grs_act_add_node_to_keep(pattern, "VProj3600_510", grs_op_VProj, mode_Bu, 81, n_VProj3600);
+       ext_grs_node_t *n_Add3588_511 = ext_grs_act_add_node_to_keep(pattern, "Add3588_511", grs_op_Add, mode_Is, 80, n_Add3588);
+       ext_grs_node_t *n_Conv2644_512 = ext_grs_act_add_node_to_keep(pattern, "Conv2644_512", grs_op_Conv, mode_Is, 82, n_Conv2644);
+       ext_grs_node_t *n_Cond2831_513 = ext_grs_act_add_node_to_keep(pattern, "Cond2831_513", grs_op_Cond, mode_T, 83, n_Cond2831);
+       ext_grs_node_t *n_Cond3179_514 = ext_grs_act_add_node_to_keep(pattern, "Cond3179_514", grs_op_Cond, mode_T, 84, n_Cond3179);
+       ext_grs_node_t *n_Conv3253_515 = ext_grs_act_add_node_to_keep(pattern, "Conv3253_515", grs_op_Conv, mode_Is, 85, n_Conv3253);
+       ext_grs_node_t *n_Block3273_516 = ext_grs_act_add_node_to_keep(pattern, "Block3273_516", grs_op_Block, mode_BB, 87, n_Block3273);
+       ext_grs_node_t *n_Block2894_517 = ext_grs_act_add_node_to_keep(pattern, "Block2894_517", grs_op_Block, mode_BB, 86, n_Block2894);
+       ext_grs_node_t *n_Block2893_518 = ext_grs_act_add_node_to_keep(pattern, "Block2893_518", grs_op_Block, mode_BB, 88, n_Block2893);
+       ext_grs_node_t *n_Jmp3731_519 = ext_grs_act_add_node_to_keep(pattern, "Jmp3731_519", grs_op_Jmp, mode_X, 89, n_Jmp3731);
+       ext_grs_node_t *n_Block2751_520 = ext_grs_act_add_node_to_keep(pattern, "Block2751_520", grs_op_Block, mode_BB, 90, n_Block2751);
+       ext_grs_node_t *n_Block2490_521 = ext_grs_act_add_node_to_keep(pattern, "Block2490_521", grs_op_Block, mode_BB, 91, n_Block2490);
+       ext_grs_node_t *n_Sub2773_522 = ext_grs_act_add_node_to_keep(pattern, "Sub2773_522", grs_op_Sub, mode_Is, 92, n_Sub2773);
+       ext_grs_node_t *n_Jmp2974_523 = ext_grs_act_add_node_to_keep(pattern, "Jmp2974_523", grs_op_Jmp, mode_X, 93, n_Jmp2974);
+       ext_grs_node_t *n_VProj2740_524 = ext_grs_act_add_node_to_keep(pattern, "VProj2740_524", grs_op_VProj, mode_Bu, 94, n_VProj2740);
+       ext_grs_node_t *n_Conv2654_525 = ext_grs_act_add_node_to_keep(pattern, "Conv2654_525", grs_op_Conv, mode_Is, 95, n_Conv2654);
+       ext_grs_node_t *n_Phi2924_526 = ext_grs_act_add_node_to_keep(pattern, "Phi2924_526", grs_op_Phi, mode_Is, 96, n_Phi2924);
+       ext_grs_node_t *n_Phi2837_527 = ext_grs_act_add_node_to_keep(pattern, "Phi2837_527", grs_op_Phi, mode_Is, 97, n_Phi2837);
+       ext_grs_node_t *n_Proj2919_528 = ext_grs_act_add_node_to_keep(pattern, "Proj2919_528", grs_op_Proj, mode_X, 98, n_Proj2919);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 290);
+       ext_grs_node_t *n_Block3241_529 = ext_grs_act_add_node_to_keep(pattern, "Block3241_529", grs_op_Block, mode_BB, 99, n_Block3241);
+       ext_grs_node_t *n_Block3242_530 = ext_grs_act_add_node_to_keep(pattern, "Block3242_530", grs_op_Block, mode_BB, 100, n_Block3242);
+       ext_grs_node_t *n_Proj2917_531 = ext_grs_act_add_node_to_keep(pattern, "Proj2917_531", grs_op_Proj, mode_b, 101, n_Proj2917);
+       ext_grs_node_t *n_Conv3263_532 = ext_grs_act_add_node_to_keep(pattern, "Conv3263_532", grs_op_Conv, mode_Is, 102, n_Conv3263);
+       ext_grs_node_t *n_Block3621_533 = ext_grs_act_add_node_to_keep(pattern, "Block3621_533", grs_op_Block, mode_BB, 103, n_Block3621);
+       ext_grs_node_t *n_Add3066_534 = ext_grs_act_add_node_to_keep(pattern, "Add3066_534", grs_op_Add, mode_Is, 104, n_Add3066);
+       ext_grs_node_t *n_Proj2920_535 = ext_grs_act_add_node_to_keep(pattern, "Proj2920_535", grs_op_Proj, mode_X, 105, n_Proj2920);
+       ext_grs_node_t *n_Proj3093_536 = ext_grs_act_add_node_to_keep(pattern, "Proj3093_536", grs_op_Proj, mode_X, 106, n_Proj3093);
+       ext_grs_node_t *n_Proj3094_537 = ext_grs_act_add_node_to_keep(pattern, "Proj3094_537", grs_op_Proj, mode_X, 107, n_Proj3094);
+       ext_grs_node_t *n_Jmp2861_538 = ext_grs_act_add_node_to_keep(pattern, "Jmp2861_538", grs_op_Jmp, mode_X, 108, n_Jmp2861);
+       ext_grs_node_t *n_Block3447_539 = ext_grs_act_add_node_to_keep(pattern, "Block3447_539", grs_op_Block, mode_BB, 109, n_Block3447);
+       ext_grs_node_t *n_Proj3091_540 = ext_grs_act_add_node_to_keep(pattern, "Proj3091_540", grs_op_Proj, mode_b, 110, n_Proj3091);
+       ext_grs_node_t *n_Block3589_541 = ext_grs_act_add_node_to_keep(pattern, "Block3589_541", grs_op_Block, mode_BB, 111, n_Block3589);
+       ext_grs_node_t *n_VProj2730_542 = ext_grs_act_add_node_to_keep(pattern, "VProj2730_542", grs_op_VProj, mode_Bu, 112, n_VProj2730);
+       ext_grs_node_t *n_Cond3266_543 = ext_grs_act_add_node_to_keep(pattern, "Cond3266_543", grs_op_Cond, mode_T, 113, n_Cond3266);
+       ext_grs_node_t *n_Jmp2713_544 = ext_grs_act_add_node_to_keep(pattern, "Jmp2713_544", grs_op_Jmp, mode_X, 114, n_Jmp2713);
+       ext_grs_node_t *n_Sub3382_545 = ext_grs_act_add_node_to_keep(pattern, "Sub3382_545", grs_op_Sub, mode_Is, 115, n_Sub3382);
+       ext_grs_node_t *n_VProj3436_546 = ext_grs_act_add_node_to_keep(pattern, "VProj3436_546", grs_op_VProj, mode_Bu, 116, n_VProj3436);
+       ext_grs_node_t *n_Block3590_547 = ext_grs_act_add_node_to_keep(pattern, "Block3590_547", grs_op_Block, mode_BB, 117, n_Block3590);
+       ext_grs_node_t *n_Conv2905_548 = ext_grs_act_add_node_to_keep(pattern, "Conv2905_548", grs_op_Conv, mode_Is, 118, n_Conv2905);
+       ext_grs_node_t *n_Conv2395_549 = ext_grs_act_add_node_to_keep(pattern, "Conv2395_549", grs_op_Conv, mode_Is, 119, n_Conv2395);
+       ext_grs_node_t *n_Jmp3583_550 = ext_grs_act_add_node_to_keep(pattern, "Jmp3583_550", grs_op_Jmp, mode_X, 120, n_Jmp3583);
+       ext_grs_node_t *n_Block3186_551 = ext_grs_act_add_node_to_keep(pattern, "Block3186_551", grs_op_Block, mode_BB, 121, n_Block3186);
+       ext_grs_node_t *n_Block2376_552 = ext_grs_act_add_node_to_keep(pattern, "Block2376_552", grs_op_Block, mode_BB, 122, n_Block2376);
+       ext_grs_node_t *n_Block2377_553 = ext_grs_act_add_node_to_keep(pattern, "Block2377_553", grs_op_Block, mode_BB, 123, n_Block2377);
+       ext_grs_node_t *n_Add2892_554 = ext_grs_act_add_node_to_keep(pattern, "Add2892_554", grs_op_Add, mode_Is, 124, n_Add2892);
+       ext_grs_node_t *n_Jmp2453_555 = ext_grs_act_add_node_to_keep(pattern, "Jmp2453_555", grs_op_Jmp, mode_X, 125, n_Jmp2453);
+       ext_grs_node_t *n_Add3327_556 = ext_grs_act_add_node_to_keep(pattern, "Add3327_556", grs_op_Add, mode_Is, 126, n_Add3327);
+       ext_grs_node_t *n_Conv3350_557 = ext_grs_act_add_node_to_keep(pattern, "Conv3350_557", grs_op_Conv, mode_Is, 127, n_Conv3350);
+       ext_grs_node_t *n_Sub2947_558 = ext_grs_act_add_node_to_keep(pattern, "Sub2947_558", grs_op_Sub, mode_Is, 128, n_Sub2947);
+       ext_grs_node_t *n_Block2720_559 = ext_grs_act_add_node_to_keep(pattern, "Block2720_559", grs_op_Block, mode_BB, 129, n_Block2720);
+       ext_grs_node_t *n_Cond2483_560 = ext_grs_act_add_node_to_keep(pattern, "Cond2483_560", grs_op_Cond, mode_T, 130, n_Cond2483);
+       ext_grs_node_t *n_Block3534_561 = ext_grs_act_add_node_to_keep(pattern, "Block3534_561", grs_op_Block, mode_BB, 131, n_Block3534);
+       ext_grs_node_t *n_Jmp3383_562 = ext_grs_act_add_node_to_keep(pattern, "Jmp3383_562", grs_op_Jmp, mode_X, 132, n_Jmp3383);
+       ext_grs_node_t *n_Cmp5646_563 = ext_grs_act_add_node_to_keep(pattern, "Cmp5646_563", grs_op_Cmp, mode_T, 133, n_Cmp5646);
+       ext_grs_node_t *n_Cmp5647_564 = ext_grs_act_add_node_to_keep(pattern, "Cmp5647_564", grs_op_Cmp, mode_T, 134, n_Cmp5647);
+       ext_grs_node_t *n_Cmp5648_565 = ext_grs_act_add_node_to_keep(pattern, "Cmp5648_565", grs_op_Cmp, mode_T, 135, n_Cmp5648);
+       ext_grs_node_t *n_Sub2512_566 = ext_grs_act_add_node_to_keep(pattern, "Sub2512_566", grs_op_Sub, mode_Is, 136, n_Sub2512);
+       ext_grs_node_t *n_Cmp5649_567 = ext_grs_act_add_node_to_keep(pattern, "Cmp5649_567", grs_op_Cmp, mode_T, 137, n_Cmp5649);
+       ext_grs_node_t *n_Block2458_568 = ext_grs_act_add_node_to_keep(pattern, "Block2458_568", grs_op_Block, mode_BB, 138, n_Block2458);
+       ext_grs_node_t *n_Cmp5645_569 = ext_grs_act_add_node_to_keep(pattern, "Cmp5645_569", grs_op_Cmp, mode_T, 139, n_Cmp5645);
+       ext_grs_node_t *n_Phi3185_570 = ext_grs_act_add_node_to_keep(pattern, "Phi3185_570", grs_op_Phi, mode_Is, 140, n_Phi3185);
+       ext_grs_node_t *n_Block2925_571 = ext_grs_act_add_node_to_keep(pattern, "Block2925_571", grs_op_Block, mode_BB, 141, n_Block2925);
+       ext_grs_node_t *n_Block2459_572 = ext_grs_act_add_node_to_keep(pattern, "Block2459_572", grs_op_Block, mode_BB, 142, n_Block2459);
+       ext_grs_node_t *n_Block2719_573 = ext_grs_act_add_node_to_keep(pattern, "Block2719_573", grs_op_Block, mode_BB, 143, n_Block2719);
+       ext_grs_node_t *n_Add3240_574 = ext_grs_act_add_node_to_keep(pattern, "Add3240_574", grs_op_Add, mode_Is, 144, n_Add3240);
+       ext_grs_node_t *n_Phi2576_575 = ext_grs_act_add_node_to_keep(pattern, "Phi2576_575", grs_op_Phi, mode_Is, 145, n_Phi2576);
+       ext_grs_node_t *n_Cond3092_576 = ext_grs_act_add_node_to_keep(pattern, "Cond3092_576", grs_op_Cond, mode_T, 146, n_Cond3092);
+       ext_grs_node_t *n_Cond2657_577 = ext_grs_act_add_node_to_keep(pattern, "Cond2657_577", grs_op_Cond, mode_T, 147, n_Cond2657);
+       ext_grs_node_t *n_Jmp3670_578 = ext_grs_act_add_node_to_keep(pattern, "Jmp3670_578", grs_op_Jmp, mode_X, 148, n_Jmp3670);
+       ext_grs_node_t *n_Conv2470_579 = ext_grs_act_add_node_to_keep(pattern, "Conv2470_579", grs_op_Conv, mode_Is, 149, n_Conv2470);
+       ext_grs_node_t *n_Conv3340_580 = ext_grs_act_add_node_to_keep(pattern, "Conv3340_580", grs_op_Conv, mode_Is, 150, n_Conv3340);
+       ext_grs_node_t *n_Block2664_581 = ext_grs_act_add_node_to_keep(pattern, "Block2664_581", grs_op_Block, mode_BB, 151, n_Block2664);
+       ext_grs_node_t *n_Conv3002_582 = ext_grs_act_add_node_to_keep(pattern, "Conv3002_582", grs_op_Conv, mode_Is, 152, n_Conv3002);
+       ext_grs_node_t *n_VProj2904_583 = ext_grs_act_add_node_to_keep(pattern, "VProj2904_583", grs_op_VProj, mode_Bu, 153, n_VProj2904);
+       ext_grs_node_t *n_Sub2426_584 = ext_grs_act_add_node_to_keep(pattern, "Sub2426_584", grs_op_Sub, mode_Is, 154, n_Sub2426);
+       ext_grs_node_t *n_Cond2398_585 = ext_grs_act_add_node_to_keep(pattern, "Cond2398_585", grs_op_Cond, mode_T, 155, n_Cond2398);
+       ext_grs_node_t *n_Cmp5659_586 = ext_grs_act_add_node_to_keep(pattern, "Cmp5659_586", grs_op_Cmp, mode_T, 156, n_Cmp5659);
+       ext_grs_node_t *n_Cmp5657_587 = ext_grs_act_add_node_to_keep(pattern, "Cmp5657_587", grs_op_Cmp, mode_T, 157, n_Cmp5657);
+       ext_grs_node_t *n_Cond2918_588 = ext_grs_act_add_node_to_keep(pattern, "Cond2918_588", grs_op_Cond, mode_T, 158, n_Cond2918);
+       ext_grs_node_t *n_Cmp5658_589 = ext_grs_act_add_node_to_keep(pattern, "Cmp5658_589", grs_op_Cmp, mode_T, 159, n_Cmp5658);
+       ext_grs_node_t *n_Block3708_590 = ext_grs_act_add_node_to_keep(pattern, "Block3708_590", grs_op_Block, mode_BB, 160, n_Block3708);
+       ext_grs_node_t *n_Conv2480_591 = ext_grs_act_add_node_to_keep(pattern, "Conv2480_591", grs_op_Conv, mode_Is, 161, n_Conv2480);
+       ext_grs_node_t *n_Cmp5656_592 = ext_grs_act_add_node_to_keep(pattern, "Cmp5656_592", grs_op_Cmp, mode_T, 162, n_Cmp5656);
+       ext_grs_node_t *n_Cmp5655_593 = ext_grs_act_add_node_to_keep(pattern, "Cmp5655_593", grs_op_Cmp, mode_T, 163, n_Cmp5655);
+       ext_grs_node_t *n_Cmp5654_594 = ext_grs_act_add_node_to_keep(pattern, "Cmp5654_594", grs_op_Cmp, mode_T, 164, n_Cmp5654);
+       ext_grs_node_t *n_Cmp5653_595 = ext_grs_act_add_node_to_keep(pattern, "Cmp5653_595", grs_op_Cmp, mode_T, 165, n_Cmp5653);
+       ext_grs_node_t *n_Cmp5652_596 = ext_grs_act_add_node_to_keep(pattern, "Cmp5652_596", grs_op_Cmp, mode_T, 166, n_Cmp5652);
+       ext_grs_node_t *n_Cmp5651_597 = ext_grs_act_add_node_to_keep(pattern, "Cmp5651_597", grs_op_Cmp, mode_T, 167, n_Cmp5651);
+       ext_grs_node_t *n_Cmp5650_598 = ext_grs_act_add_node_to_keep(pattern, "Cmp5650_598", grs_op_Cmp, mode_T, 168, n_Cmp5650);
+       ext_grs_node_t *n_Conv2386_599 = ext_grs_act_add_node_to_keep(pattern, "Conv2386_599", grs_op_Conv, mode_Is, 169, n_Conv2386);
+       ext_grs_node_t *n_Proj2397_600 = ext_grs_act_add_node_to_keep(pattern, "Proj2397_600", grs_op_Proj, mode_b, 170, n_Proj2397);
+       ext_grs_node_t *n_Proj2399_601 = ext_grs_act_add_node_to_keep(pattern, "Proj2399_601", grs_op_Proj, mode_X, 171, n_Proj2399);
+       ext_grs_node_t *n_Phi2663_602 = ext_grs_act_add_node_to_keep(pattern, "Phi2663_602", grs_op_Phi, mode_Is, 172, n_Phi2663);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 291);
+       ext_grs_node_t *n_Block3415_603 = ext_grs_act_add_node_to_keep(pattern, "Block3415_603", grs_op_Block, mode_BB, 173, n_Block3415);
+       ext_grs_node_t *n_Block3416_604 = ext_grs_act_add_node_to_keep(pattern, "Block3416_604", grs_op_Block, mode_BB, 174, n_Block3416);
+       ext_grs_node_t *n_Jmp3757_605 = ext_grs_act_add_node_to_keep(pattern, "Jmp3757_605", grs_op_Jmp, mode_X, 175, n_Jmp3757);
+       ext_grs_node_t *n_Block2632_606 = ext_grs_act_add_node_to_keep(pattern, "Block2632_606", grs_op_Block, mode_BB, 176, n_Block2632);
+       ext_grs_node_t *n_Phi3533_607 = ext_grs_act_add_node_to_keep(pattern, "Phi3533_607", grs_op_Phi, mode_Is, 177, n_Phi3533);
+       ext_grs_node_t *n_Proj3265_608 = ext_grs_act_add_node_to_keep(pattern, "Proj3265_608", grs_op_Proj, mode_b, 178, n_Proj3265);
+       ext_grs_node_t *n_Proj3267_609 = ext_grs_act_add_node_to_keep(pattern, "Proj3267_609", grs_op_Proj, mode_X, 179, n_Proj3267);
+       ext_grs_node_t *n_Conv3601_610 = ext_grs_act_add_node_to_keep(pattern, "Conv3601_610", grs_op_Conv, mode_Is, 180, n_Conv3601);
+       ext_grs_node_t *n_Proj3268_611 = ext_grs_act_add_node_to_keep(pattern, "Proj3268_611", grs_op_Proj, mode_X, 181, n_Proj3268);
+       ext_grs_node_t *n_Jmp3122_612 = ext_grs_act_add_node_to_keep(pattern, "Jmp3122_612", grs_op_Jmp, mode_X, 183, n_Jmp3122);
+       ext_grs_node_t *n_Cond3614_613 = ext_grs_act_add_node_to_keep(pattern, "Cond3614_613", grs_op_Cond, mode_T, 182, n_Cond3614);
+       ext_grs_node_t *n_Conv3437_614 = ext_grs_act_add_node_to_keep(pattern, "Conv3437_614", grs_op_Conv, mode_Is, 184, n_Conv3437);
+       ext_grs_node_t *n_Block2633_615 = ext_grs_act_add_node_to_keep(pattern, "Block2633_615", grs_op_Block, mode_BB, 186, n_Block2633);
+       ext_grs_node_t *n_Sub2625_616 = ext_grs_act_add_node_to_keep(pattern, "Sub2625_616", grs_op_Sub, mode_Is, 185, n_Sub2625);
+       ext_grs_node_t *n_Sub2538_617 = ext_grs_act_add_node_to_keep(pattern, "Sub2538_617", grs_op_Sub, mode_Is, 187, n_Sub2538);
+       ext_grs_node_t *n_Block3155_618 = ext_grs_act_add_node_to_keep(pattern, "Block3155_618", grs_op_Block, mode_BB, 188, n_Block3155);
+       ext_grs_node_t *n_Sub3295_619 = ext_grs_act_add_node_to_keep(pattern, "Sub3295_619", grs_op_Sub, mode_Is, 190, n_Sub3295);
+       ext_grs_node_t *n_Block3154_620 = ext_grs_act_add_node_to_keep(pattern, "Block3154_620", grs_op_Block, mode_BB, 189, n_Block3154);
+       ext_grs_node_t *n_Proj2656_621 = ext_grs_act_add_node_to_keep(pattern, "Proj2656_621", grs_op_Proj, mode_b, 191, n_Proj2656);
+       ext_grs_node_t *n_Proj2658_622 = ext_grs_act_add_node_to_keep(pattern, "Proj2658_622", grs_op_Proj, mode_X, 192, n_Proj2658);
+       ext_grs_node_t *n_Proj2659_623 = ext_grs_act_add_node_to_keep(pattern, "Proj2659_623", grs_op_Proj, mode_X, 193, n_Proj2659);
+       ext_grs_node_t *n_Conv2557_624 = ext_grs_act_add_node_to_keep(pattern, "Conv2557_624", grs_op_Conv, mode_Is, 194, n_Conv2557);
+       ext_grs_node_t *n_Jmp3557_625 = ext_grs_act_add_node_to_keep(pattern, "Jmp3557_625", grs_op_Jmp, mode_X, 196, n_Jmp3557);
+       ext_grs_node_t *n_VProj3697_626 = ext_grs_act_add_node_to_keep(pattern, "VProj3697_626", grs_op_VProj, mode_Bu, 195, n_VProj3697);
+       ext_grs_node_t *n_VProj290_627 = ext_grs_act_add_node_to_keep(pattern, "VProj290_627", grs_op_VProj, mode_Is, 292, n_Vector_Result0_Add3762);
+       ext_grs_node_t *n_Block3012_628 = ext_grs_act_add_node_to_keep(pattern, "Block3012_628", grs_op_Block, mode_BB, 198, n_Block3012);
+       ext_grs_node_t *n_Jmp3235_629 = ext_grs_act_add_node_to_keep(pattern, "Jmp3235_629", grs_op_Jmp, mode_X, 199, n_Jmp3235);
+       ext_grs_node_t *n_Block2838_630 = ext_grs_act_add_node_to_keep(pattern, "Block2838_630", grs_op_Block, mode_BB, 201, n_Block2838);
+       ext_grs_node_t *n_Sub2712_631 = ext_grs_act_add_node_to_keep(pattern, "Sub2712_631", grs_op_Sub, mode_Is, 200, n_Sub2712);
+       ext_grs_node_t *n_Add3153_632 = ext_grs_act_add_node_to_keep(pattern, "Add3153_632", grs_op_Add, mode_Is, 203, n_Add3153);
+       ext_grs_node_t *n_Block2545_633 = ext_grs_act_add_node_to_keep(pattern, "Block2545_633", grs_op_Block, mode_BB, 202, n_Block2545);
+       ext_grs_node_t *n_Block2546_634 = ext_grs_act_add_node_to_keep(pattern, "Block2546_634", grs_op_Block, mode_BB, 205, n_Block2546);
+       ext_grs_node_t *n_Phi3359_635 = ext_grs_act_add_node_to_keep(pattern, "Phi3359_635", grs_op_Phi, mode_Is, 204, n_Phi3359);
+       ext_grs_node_t *n_Conv3611_636 = ext_grs_act_add_node_to_keep(pattern, "Conv3611_636", grs_op_Conv, mode_Is, 206, n_Conv3611);
+       ext_grs_node_t *n_Conv3524_637 = ext_grs_act_add_node_to_keep(pattern, "Conv3524_637", grs_op_Conv, mode_Is, 207, n_Conv3524);
+       ext_grs_node_t *n_Proj3355_638 = ext_grs_act_add_node_to_keep(pattern, "Proj3355_638", grs_op_Proj, mode_X, 209, n_Proj3355);
+       ext_grs_node_t *n_Conv3427_639 = ext_grs_act_add_node_to_keep(pattern, "Conv3427_639", grs_op_Conv, mode_Is, 208, n_Conv3427);
+       ext_grs_node_t *n_Cond3353_640 = ext_grs_act_add_node_to_keep(pattern, "Cond3353_640", grs_op_Cond, mode_T, 210, n_Cond3353);
+       ext_grs_node_t *n_VProj3001_641 = ext_grs_act_add_node_to_keep(pattern, "VProj3001_641", grs_op_VProj, mode_Bu, 212, n_VProj3001);
+       ext_grs_node_t *n_Cond2744_642 = ext_grs_act_add_node_to_keep(pattern, "Cond2744_642", grs_op_Cond, mode_T, 211, n_Cond2744);
+       ext_grs_node_t *n_Proj3354_643 = ext_grs_act_add_node_to_keep(pattern, "Proj3354_643", grs_op_Proj, mode_X, 214, n_Proj3354);
+       ext_grs_node_t *n_VProj3165_644 = ext_grs_act_add_node_to_keep(pattern, "VProj3165_644", grs_op_VProj, mode_Bu, 213, n_VProj3165);
+       ext_grs_node_t *n_Proj3352_645 = ext_grs_act_add_node_to_keep(pattern, "Proj3352_645", grs_op_Proj, mode_b, 215, n_Proj3352);
+       ext_grs_node_t *n_Add3414_646 = ext_grs_act_add_node_to_keep(pattern, "Add3414_646", grs_op_Add, mode_Is, 216, n_Add3414);
+       ext_grs_node_t *n_Conv2567_647 = ext_grs_act_add_node_to_keep(pattern, "Conv2567_647", grs_op_Conv, mode_Is, 217, n_Conv2567);
+       ext_grs_node_t *n_Sub3495_648 = ext_grs_act_add_node_to_keep(pattern, "Sub3495_648", grs_op_Sub, mode_Is, 218, n_Sub3495);
+       ext_grs_node_t *n_Jmp3148_649 = ext_grs_act_add_node_to_keep(pattern, "Jmp3148_649", grs_op_Jmp, mode_X, 219, n_Jmp3148);
+       ext_grs_node_t *n_Jmp2800_650 = ext_grs_act_add_node_to_keep(pattern, "Jmp2800_650", grs_op_Jmp, mode_X, 220, n_Jmp2800);
+       ext_grs_node_t *n_Sub2599_651 = ext_grs_act_add_node_to_keep(pattern, "Sub2599_651", grs_op_Sub, mode_Is, 221, n_Sub2599);
+       ext_grs_node_t *n_VProj3175_652 = ext_grs_act_add_node_to_keep(pattern, "VProj3175_652", grs_op_VProj, mode_Bu, 222, n_VProj3175);
+       ext_grs_node_t *n_Sub3408_653 = ext_grs_act_add_node_to_keep(pattern, "Sub3408_653", grs_op_Sub, mode_Is, 223, n_Sub3408);
+       ext_grs_node_t *n_VProj3078_654 = ext_grs_act_add_node_to_keep(pattern, "VProj3078_654", grs_op_VProj, mode_Bu, 225, n_VProj3078);
+       ext_grs_node_t *n_Sub2452_655 = ext_grs_act_add_node_to_keep(pattern, "Sub2452_655", grs_op_Sub, mode_Is, 224, n_Sub2452);
+       ext_grs_node_t *n_Conv2741_656 = ext_grs_act_add_node_to_keep(pattern, "Conv2741_656", grs_op_Conv, mode_Is, 226, n_Conv2741);
+       ext_grs_node_t *n_Proj3004_657 = ext_grs_act_add_node_to_keep(pattern, "Proj3004_657", grs_op_Proj, mode_b, 227, n_Proj3004);
+       ext_grs_node_t *n_Add3501_658 = ext_grs_act_add_node_to_keep(pattern, "Add3501_658", grs_op_Add, mode_Is, 228, n_Add3501);
+       ext_grs_node_t *n_Cond3005_659 = ext_grs_act_add_node_to_keep(pattern, "Cond3005_659", grs_op_Cond, mode_T, 229, n_Cond3005);
+       ext_grs_node_t *n_Proj2482_660 = ext_grs_act_add_node_to_keep(pattern, "Proj2482_660", grs_op_Proj, mode_b, 230, n_Proj2482);
+       ext_grs_node_t *n_Proj2571_661 = ext_grs_act_add_node_to_keep(pattern, "Proj2571_661", grs_op_Proj, mode_X, 231, n_Proj2571);
+       ext_grs_node_t *n_Proj2572_662 = ext_grs_act_add_node_to_keep(pattern, "Proj2572_662", grs_op_Proj, mode_X, 234, n_Proj2572);
+       ext_grs_node_t *n_Jmp2774_663 = ext_grs_act_add_node_to_keep(pattern, "Jmp2774_663", grs_op_Jmp, mode_X, 233, n_Jmp2774);
+       ext_grs_node_t *n_Proj3006_664 = ext_grs_act_add_node_to_keep(pattern, "Proj3006_664", grs_op_Proj, mode_X, 232, n_Proj3006);
+       ext_grs_node_t *n_Proj3007_665 = ext_grs_act_add_node_to_keep(pattern, "Proj3007_665", grs_op_Proj, mode_X, 237, n_Proj3007);
+       ext_grs_node_t *n_Proj2485_666 = ext_grs_act_add_node_to_keep(pattern, "Proj2485_666", grs_op_Proj, mode_X, 236, n_Proj2485);
+       ext_grs_node_t *n_Sub3469_667 = ext_grs_act_add_node_to_keep(pattern, "Sub3469_667", grs_op_Sub, mode_Is, 235, n_Sub3469);
+       ext_grs_node_t *n_Proj2484_668 = ext_grs_act_add_node_to_keep(pattern, "Proj2484_668", grs_op_Proj, mode_X, 238, n_Proj2484);
+       ext_grs_node_t *n_Add3675_669 = ext_grs_act_add_node_to_keep(pattern, "Add3675_669", grs_op_Add, mode_Is, 239, n_Add3675);
+       ext_grs_node_t *n_VProj2556_670 = ext_grs_act_add_node_to_keep(pattern, "VProj2556_670", grs_op_VProj, mode_Bu, 240, n_VProj2556);
+       ext_grs_node_t *n_Jmp3296_671 = ext_grs_act_add_node_to_keep(pattern, "Jmp3296_671", grs_op_Jmp, mode_X, 241, n_Jmp3296);
+       ext_grs_node_t *n_VProj3088_672 = ext_grs_act_add_node_to_keep(pattern, "VProj3088_672", grs_op_VProj, mode_Bu, 242, n_VProj3088);
+       ext_grs_node_t *n_Phi3272_673 = ext_grs_act_add_node_to_keep(pattern, "Phi3272_673", grs_op_Phi, mode_Is, 244, n_Phi3272);
+       ext_grs_node_t *n_Add2631_674 = ext_grs_act_add_node_to_keep(pattern, "Add2631_674", grs_op_Add, mode_Is, 243, n_Add2631);
+       ext_grs_node_t *n_VProj3687_675 = ext_grs_act_add_node_to_keep(pattern, "VProj3687_675", grs_op_VProj, mode_Bu, 245, n_VProj3687);
+       ext_grs_node_t *n_Block2806_676 = ext_grs_act_add_node_to_keep(pattern, "Block2806_676", grs_op_Block, mode_BB, 249, n_Block2806);
+       ext_grs_node_t *n_Jmp2687_677 = ext_grs_act_add_node_to_keep(pattern, "Jmp2687_677", grs_op_Jmp, mode_X, 248, n_Jmp2687);
+       ext_grs_node_t *n_Conv2731_678 = ext_grs_act_add_node_to_keep(pattern, "Conv2731_678", grs_op_Conv, mode_Is, 247, n_Conv2731);
+       ext_grs_node_t *n_Sub2973_679 = ext_grs_act_add_node_to_keep(pattern, "Sub2973_679", grs_op_Sub, mode_Is, 246, n_Sub2973);
+       ext_grs_node_t *n_Jmp3496_680 = ext_grs_act_add_node_to_keep(pattern, "Jmp3496_680", grs_op_Jmp, mode_X, 251, n_Jmp3496);
+       ext_grs_node_t *n_Block2807_681 = ext_grs_act_add_node_to_keep(pattern, "Block2807_681", grs_op_Block, mode_BB, 250, n_Block2807);
+       ext_grs_node_t *n_Proj2569_682 = ext_grs_act_add_node_to_keep(pattern, "Proj2569_682", grs_op_Proj, mode_b, 252, n_Proj2569);
+       ext_grs_node_t *n_Conv3176_683 = ext_grs_act_add_node_to_keep(pattern, "Conv3176_683", grs_op_Conv, mode_Is, 253, n_Conv3176);
+       ext_grs_node_t *n_VProj2817_684 = ext_grs_act_add_node_to_keep(pattern, "VProj2817_684", grs_op_VProj, mode_Bu, 254, n_VProj2817);
+       ext_grs_node_t *n_Block2577_685 = ext_grs_act_add_node_to_keep(pattern, "Block2577_685", grs_op_Block, mode_BB, 255, n_Block2577);
+       ext_grs_node_t *n_Conv3079_686 = ext_grs_act_add_node_to_keep(pattern, "Conv3079_686", grs_op_Conv, mode_Is, 256, n_Conv3079);
+       ext_grs_node_t *n_Add2805_687 = ext_grs_act_add_node_to_keep(pattern, "Add2805_687", grs_op_Add, mode_Is, 258, n_Add2805);
+       ext_grs_node_t *n_VProj2914_688 = ext_grs_act_add_node_to_keep(pattern, "VProj2914_688", grs_op_VProj, mode_Bu, 257, n_VProj2914);
+       ext_grs_node_t *n_Block2980_689 = ext_grs_act_add_node_to_keep(pattern, "Block2980_689", grs_op_Block, mode_BB, 260, n_Block2980);
+       ext_grs_node_t *n_Proj3613_690 = ext_grs_act_add_node_to_keep(pattern, "Proj3613_690", grs_op_Proj, mode_b, 259, n_Proj3613);
+       ext_grs_node_t *n_VProj3252_691 = ext_grs_act_add_node_to_keep(pattern, "VProj3252_691", grs_op_VProj, mode_Bu, 262, n_VProj3252);
+       ext_grs_node_t *n_Block2981_692 = ext_grs_act_add_node_to_keep(pattern, "Block2981_692", grs_op_Block, mode_BB, 261, n_Block2981);
+       ext_grs_node_t *n_Sub2860_693 = ext_grs_act_add_node_to_keep(pattern, "Sub2860_693", grs_op_Sub, mode_Is, 264, n_Sub2860);
+       ext_grs_node_t *n_Proj3615_694 = ext_grs_act_add_node_to_keep(pattern, "Proj3615_694", grs_op_Proj, mode_X, 263, n_Proj3615);
+       ext_grs_node_t *n_Proj3616_695 = ext_grs_act_add_node_to_keep(pattern, "Proj3616_695", grs_op_Proj, mode_X, 265, n_Proj3616);
+       ext_grs_node_t *n_Cmp5660_696 = ext_grs_act_add_node_to_keep(pattern, "Cmp5660_696", grs_op_Cmp, mode_T, 267, n_Cmp5660);
+       ext_grs_node_t *n_Jmp2513_697 = ext_grs_act_add_node_to_keep(pattern, "Jmp2513_697", grs_op_Jmp, mode_X, 266, n_Jmp2513);
+       ext_grs_node_t *n_Sub3582_698 = ext_grs_act_add_node_to_keep(pattern, "Sub3582_698", grs_op_Sub, mode_Is, 268, n_Sub3582);
+       ext_grs_node_t *n_Sub3060_699 = ext_grs_act_add_node_to_keep(pattern, "Sub3060_699", grs_op_Sub, mode_Is, 269, n_Sub3060);
+       ext_grs_node_t *n_Proj3529_700 = ext_grs_act_add_node_to_keep(pattern, "Proj3529_700", grs_op_Proj, mode_X, 270, n_Proj3529);
+       ext_grs_node_t *n_Proj3528_701 = ext_grs_act_add_node_to_keep(pattern, "Proj3528_701", grs_op_Proj, mode_X, 271, n_Proj3528);
+       ext_grs_node_t *n_Phi3446_702 = ext_grs_act_add_node_to_keep(pattern, "Phi3446_702", grs_op_Phi, mode_Is, 273, n_Phi3446);
+       ext_grs_node_t *n_Add2718_703 = ext_grs_act_add_node_to_keep(pattern, "Add2718_703", grs_op_Add, mode_Is, 272, n_Add2718);
+       ext_grs_node_t *n_Proj3526_704 = ext_grs_act_add_node_to_keep(pattern, "Proj3526_704", grs_op_Proj, mode_b, 276, n_Proj3526);
+       ext_grs_node_t *n_Conv3166_705 = ext_grs_act_add_node_to_keep(pattern, "Conv3166_705", grs_op_Conv, mode_Is, 274, n_Conv3166);
+       ext_grs_node_t *n_Vector_op_Block_706 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_706", grs_op_Block, mode_BB, 275, n_Vector_op_Block);
+       ext_grs_node_t *n_VProj2827_707 = ext_grs_act_add_node_to_keep(pattern, "VProj2827_707", grs_op_VProj, mode_Bu, 277, n_VProj2827);
+       ext_grs_node_t *n_Block3503_708 = ext_grs_act_add_node_to_keep(pattern, "Block3503_708", grs_op_Block, mode_BB, 278, n_Block3503);
+       ext_grs_node_t *n_Block3502_709 = ext_grs_act_add_node_to_keep(pattern, "Block3502_709", grs_op_Block, mode_BB, 279, n_Block3502);
+       ext_grs_node_t *n_Jmp3470_710 = ext_grs_act_add_node_to_keep(pattern, "Jmp3470_710", grs_op_Jmp, mode_X, 281, n_Jmp3470);
+       ext_grs_node_t *n_Proj2745_711 = ext_grs_act_add_node_to_keep(pattern, "Proj2745_711", grs_op_Proj, mode_X, 280, n_Proj2745);
+       ext_grs_node_t *n_Proj2746_712 = ext_grs_act_add_node_to_keep(pattern, "Proj2746_712", grs_op_Proj, mode_X, 282, n_Proj2746);
+       ext_grs_node_t *n_Proj2743_713 = ext_grs_act_add_node_to_keep(pattern, "Proj2743_713", grs_op_Proj, mode_b, 283, n_Proj2743);
+       ext_grs_node_t *n_Cond3701_714 = ext_grs_act_add_node_to_keep(pattern, "Cond3701_714", grs_op_Cond, mode_T, 284, n_Cond3701);
+       ext_grs_node_t *n_Jmp3644_715 = ext_grs_act_add_node_to_keep(pattern, "Jmp3644_715", grs_op_Jmp, mode_X, 285, n_Jmp3644);
+       ext_grs_node_t *n_Conv2992_716 = ext_grs_act_add_node_to_keep(pattern, "Conv2992_716", grs_op_Conv, mode_Is, 286, n_Conv2992);
+       ext_grs_node_t *n_VProj3262_717 = ext_grs_act_add_node_to_keep(pattern, "VProj3262_717", grs_op_VProj, mode_Bu, 287, n_VProj3262);
+       ext_grs_node_t *n_Phi3011_718 = ext_grs_act_add_node_to_keep(pattern, "Phi3011_718", grs_op_Phi, mode_Is, 288, n_Phi3011);
+       ext_grs_node_t *n_Block2404_719 = ext_grs_act_add_node_to_keep(pattern, "Block2404_719", grs_op_Block, mode_BB, 289, n_Block2404);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_e334_720 = ext_grs_act_add_edge_to_keep(pattern, "e334_720", ext_grs_NO_EDGE_POS, n_Proj3180_460, n_Block3155_618, 1, e_e334);
+       ext_grs_edge_t *e_e624_721 = ext_grs_act_add_edge_to_keep(pattern, "e624_721", ext_grs_NO_EDGE_POS, n_Jmp3035_479, n_Block3012_628, 0, e_e624);
+       ext_grs_edge_t *e_e430_722 = ext_grs_act_add_edge_to_keep(pattern, "e430_722", ext_grs_NO_EDGE_POS, n_Phi3446_702, n_Add3414_646, 3, e_e430);
+       ext_grs_edge_t *e_e625_723 = ext_grs_act_add_edge_to_keep(pattern, "e625_723", ext_grs_NO_EDGE_POS, n_Jmp3061_448, n_Block3012_628, 2, e_e625);
+       ext_grs_edge_t *e_e431_724 = ext_grs_act_add_edge_to_keep(pattern, "e431_724", ext_grs_NO_EDGE_POS, n_Add3327_556, n_Add3414_646, 4, e_e431);
+       ext_grs_edge_t *e_e523_725 = ext_grs_act_add_edge_to_keep(pattern, "e523_725", ext_grs_NO_EDGE_POS, n_Jmp2861_538, n_Block2838_630, 5, e_e523);
+       ext_grs_edge_t *e_e524_726 = ext_grs_act_add_edge_to_keep(pattern, "e524_726", ext_grs_NO_EDGE_POS, n_Jmp2887_500, n_Block2838_630, 6, e_e524);
+       ext_grs_edge_t *e_pos2_621_727 = ext_grs_act_add_edge_to_keep(pattern, "pos2_621_727", 1, n_Conv2470_579, n_Sub2538_617, 7, e_pos2_621);
+       ext_grs_edge_t *e_e433_728 = ext_grs_act_add_edge_to_keep(pattern, "e433_728", ext_grs_NO_EDGE_POS, n_Jmp2513_697, n_Block2490_521, 8, e_e433);
+       ext_grs_edge_t *e_e526_729 = ext_grs_act_add_edge_to_keep(pattern, "e526_729", ext_grs_NO_EDGE_POS, n_Proj3702_469, n_Block3677_491, 9, e_e526);
+       ext_grs_edge_t *e_e434_730 = ext_grs_act_add_edge_to_keep(pattern, "e434_730", ext_grs_NO_EDGE_POS, n_Jmp2539_450, n_Block2490_521, 10, e_e434);
+       ext_grs_edge_t *e_e331_731 = ext_grs_act_add_edge_to_keep(pattern, "e331_731", ext_grs_NO_EDGE_POS, n_Phi3707_456, n_Add3675_669, 11, e_e331);
+       ext_grs_edge_t *e_e332_732 = ext_grs_act_add_edge_to_keep(pattern, "e332_732", ext_grs_NO_EDGE_POS, n_Add3588_511, n_Add3675_669, 12, e_e332);
+       ext_grs_edge_t *e_pos0_324_733 = ext_grs_act_add_edge_to_keep(pattern, "pos0_324_733", -1, n_Block3415_603, n_Jmp3470_710, 13, e_pos0_324);
+       ext_grs_edge_t *e_pos2_629_734 = ext_grs_act_add_edge_to_keep(pattern, "pos2_629_734", 1, n_Conv3524_637, n_Sub3556_432, 14, e_pos2_629);
+       ext_grs_edge_t *e_pos2_385_735 = ext_grs_act_add_edge_to_keep(pattern, "pos2_385_735", 1, n_Conv3437_614, n_Sub3469_667, 15, e_pos2_385);
+       ext_grs_edge_t *e_e325_736 = ext_grs_act_add_edge_to_keep(pattern, "e325_736", ext_grs_NO_EDGE_POS, n_Jmp2948_442, n_Block2925_571, 18, e_e325);
+       ext_grs_edge_t *e_e420_737 = ext_grs_act_add_edge_to_keep(pattern, "e420_737", ext_grs_NO_EDGE_POS, n_Jmp3731_519, n_Block3708_590, 17, e_e420);
+       ext_grs_edge_t *e_e637_738 = ext_grs_act_add_edge_to_keep(pattern, "e637_738", ext_grs_NO_EDGE_POS, n_Phi2924_526, n_Add2892_554, 16, e_e637);
+       ext_grs_edge_t *e_e326_739 = ext_grs_act_add_edge_to_keep(pattern, "e326_739", ext_grs_NO_EDGE_POS, n_Jmp2974_523, n_Block2925_571, 21, e_e326);
+       ext_grs_edge_t *e_e421_740 = ext_grs_act_add_edge_to_keep(pattern, "e421_740", ext_grs_NO_EDGE_POS, n_Jmp3757_605, n_Block3708_590, 20, e_e421);
+       ext_grs_edge_t *e_e638_741 = ext_grs_act_add_edge_to_keep(pattern, "e638_741", ext_grs_NO_EDGE_POS, n_Add2805_687, n_Add2892_554, 19, e_e638);
+       ext_grs_edge_t *e_pos2_470_742 = ext_grs_act_add_edge_to_keep(pattern, "pos2_470_742", 1, n_Conv2395_549, n_Sub2426_584, 22, e_pos2_470);
+       ext_grs_edge_t *e_pos2_576_743 = ext_grs_act_add_edge_to_keep(pattern, "pos2_576_743", 1, n_Conv2395_549, n_Cmp5645_569, 24, e_pos2_576);
+       ext_grs_edge_t *e_e631_744 = ext_grs_act_add_edge_to_keep(pattern, "e631_744", ext_grs_NO_EDGE_POS, n_Jmp2427_470, n_Block2404_719, 23, e_e631);
+       ext_grs_edge_t *e_e632_745 = ext_grs_act_add_edge_to_keep(pattern, "e632_745", ext_grs_NO_EDGE_POS, n_Jmp2453_555, n_Block2404_719, 25, e_e632);
+       ext_grs_edge_t *e_e428_746 = ext_grs_act_add_edge_to_keep(pattern, "e428_746", ext_grs_NO_EDGE_POS, n_Jmp3148_649, n_Block3099_472, 26, e_e428);
+       ext_grs_edge_t *e_e535_747 = ext_grs_act_add_edge_to_keep(pattern, "e535_747", ext_grs_NO_EDGE_POS, n_Proj3093_536, n_Block3068_508, 27, e_e535);
+       ext_grs_edge_t *e_e427_748 = ext_grs_act_add_edge_to_keep(pattern, "e427_748", ext_grs_NO_EDGE_POS, n_Jmp3122_612, n_Block3099_472, 28, e_e427);
+       ext_grs_edge_t *e_e321_749 = ext_grs_act_add_edge_to_keep(pattern, "e321_749", ext_grs_NO_EDGE_POS, n_Sub2599_651, n_Phi2663_602, 30, e_e321);
+       ext_grs_edge_t *e_pos2_570_750 = ext_grs_act_add_edge_to_keep(pattern, "pos2_570_750", 1, n_Conv3698_483, n_Cmp5660_696, 29, e_pos2_570);
+       ext_grs_edge_t *e_e322_751 = ext_grs_act_add_edge_to_keep(pattern, "e322_751", ext_grs_NO_EDGE_POS, n_Sub2625_616, n_Phi2663_602, 32, e_e322);
+       ext_grs_edge_t *e_pos0_512_752 = ext_grs_act_add_edge_to_keep(pattern, "pos0_512_752", -1, n_Vector_op_Block_706, n_Cond2398_585, 31, e_pos0_512);
+       ext_grs_edge_t *e_e320_753 = ext_grs_act_add_edge_to_keep(pattern, "e320_753", ext_grs_NO_EDGE_POS, n_Block2577_685, n_Phi2663_602, 34, e_e320);
+       ext_grs_edge_t *e_pos0_514_754 = ext_grs_act_add_edge_to_keep(pattern, "pos0_514_754", -1, n_Block2981_692, n_Sub3060_699, 33, e_pos0_514);
+       ext_grs_edge_t *e_e733_755 = ext_grs_act_add_edge_to_keep(pattern, "e733_755", ext_grs_NO_EDGE_POS, n_Phi2576_575, n_Add2544_476, 35, e_e733);
+       ext_grs_edge_t *e_pos0_311_756 = ext_grs_act_add_edge_to_keep(pattern, "pos0_311_756", -1, n_Block3155_618, n_Jmp3235_629, 36, e_pos0_311);
+       ext_grs_edge_t *e_pos0_519_757 = ext_grs_act_add_edge_to_keep(pattern, "pos0_519_757", -1, n_Block3329_435, n_Sub3408_653, 38, e_pos0_519);
+       ext_grs_edge_t *e_pos2_614_758 = ext_grs_act_add_edge_to_keep(pattern, "pos2_614_758", 1, n_Conv3350_557, n_Sub3382_545, 37, e_pos2_614);
+       ext_grs_edge_t *e_pos2_373_759 = ext_grs_act_add_edge_to_keep(pattern, "pos2_373_759", 1, n_Conv3176_683, n_Cmp5654_594, 39, e_pos2_373);
+       ext_grs_edge_t *e_pos0_316_760 = ext_grs_act_add_edge_to_keep(pattern, "pos0_316_760", -1, n_Block2751_520, n_Cond2831_513, 40, e_pos0_316);
+       ext_grs_edge_t *e_pos2_371_761 = ext_grs_act_add_edge_to_keep(pattern, "pos2_371_761", 1, n_Conv3263_532, n_Sub3295_619, 41, e_pos2_371);
+       ext_grs_edge_t *e_e734_762 = ext_grs_act_add_edge_to_keep(pattern, "e734_762", ext_grs_NO_EDGE_POS, n_Phi2489_467, n_Add2544_476, 42, e_e734);
+       ext_grs_edge_t *e_pos2_376_763 = ext_grs_act_add_edge_to_keep(pattern, "pos2_376_763", 1, n_Conv2386_599, n_Sub2452_655, 43, e_pos2_376);
+       ext_grs_edge_t *e_pos2_756_764 = ext_grs_act_add_edge(pattern, "pos2_756_764", 1, n_Arg_1_509, n_Vector_op, 462);
+       ext_grs_edge_t *e_e645_765 = ext_grs_act_add_edge_to_keep(pattern, "e645_765", ext_grs_NO_EDGE_POS, n_Proj3267_609, n_Block3242_530, 44, e_e645);
+       ext_grs_edge_t *e_e312_766 = ext_grs_act_add_edge_to_keep(pattern, "e312_766", ext_grs_NO_EDGE_POS, n_Jmp3557_625, n_Block3534_561, 45, e_e312);
+       ext_grs_edge_t *e_pos2_741_767 = ext_grs_act_add_edge_to_keep(pattern, "pos2_741_767", 1, n_Conv2905_548, n_Sub2973_679, 46, e_pos2_741);
+       ext_grs_edge_t *e_e452_768 = ext_grs_act_add_edge_to_keep(pattern, "e452_768", ext_grs_NO_EDGE_POS, n_Block3708_590, n_Phi3870_482, 47, e_e452);
+       ext_grs_edge_t *e_e313_769 = ext_grs_act_add_edge_to_keep(pattern, "e313_769", ext_grs_NO_EDGE_POS, n_Jmp3583_550, n_Block3534_561, 48, e_e313);
+       ext_grs_edge_t *e_e453_770 = ext_grs_act_add_edge_to_keep(pattern, "e453_770", ext_grs_NO_EDGE_POS, n_Sub3730_477, n_Phi3870_482, 49, e_e453);
+       ext_grs_edge_t *e_e454_771 = ext_grs_act_add_edge_to_keep(pattern, "e454_771", ext_grs_NO_EDGE_POS, n_Sub3756_445, n_Phi3870_482, 50, e_e454);
+       ext_grs_edge_t *e_e709_772 = ext_grs_act_add_edge_to_keep(pattern, "e709_772", ext_grs_NO_EDGE_POS, n_Add2544_476, n_Add2631_674, 51, e_e709);
+       ext_grs_edge_t *e_e504_773 = ext_grs_act_add_edge_to_keep(pattern, "e504_773", ext_grs_NO_EDGE_POS, n_Proj2833_490, n_Block2806_676, 52, e_e504);
+       ext_grs_edge_t *e_e456_774 = ext_grs_act_add_edge_to_keep(pattern, "e456_774", ext_grs_NO_EDGE_POS, n_Phi3359_635, n_Add3327_556, 53, e_e456);
+       ext_grs_edge_t *e_e457_775 = ext_grs_act_add_edge_to_keep(pattern, "e457_775", ext_grs_NO_EDGE_POS, n_Add3240_574, n_Add3327_556, 54, e_e457);
+       ext_grs_edge_t *e_e310_776 = ext_grs_act_add_edge_to_keep(pattern, "e310_776", ext_grs_NO_EDGE_POS, n_Proj2745_711, n_Block2720_559, 55, e_e310);
+       ext_grs_edge_t *e_pos2_644_777 = ext_grs_act_add_edge_to_keep(pattern, "pos2_644_777", 1, n_Conv2567_647, n_Cmp5647_564, 56, e_pos2_644);
+       ext_grs_edge_t *e_e705_778 = ext_grs_act_add_edge_to_keep(pattern, "e705_778", ext_grs_NO_EDGE_POS, n_Sub2947_558, n_Phi3011_718, 57, e_e705);
+       ext_grs_edge_t *e_e459_779 = ext_grs_act_add_edge_to_keep(pattern, "e459_779", ext_grs_NO_EDGE_POS, n_Block3012_628, n_Phi3098_497, 58, e_e459);
+       ext_grs_edge_t *e_e706_780 = ext_grs_act_add_edge_to_keep(pattern, "e706_780", ext_grs_NO_EDGE_POS, n_Sub2973_679, n_Phi3011_718, 59, e_e706);
+       ext_grs_edge_t *e_e500_781 = ext_grs_act_add_edge_to_keep(pattern, "e500_781", ext_grs_NO_EDGE_POS, n_Phi3272_673, n_Add3240_574, 60, e_e500);
+       ext_grs_edge_t *e_pos2_467_782 = ext_grs_act_add_edge_to_keep(pattern, "pos2_467_782", 1, n_Conv3437_614, n_Cmp5657_587, 61, e_pos2_467);
+       ext_grs_edge_t *e_pos2_641_783 = ext_grs_act_add_edge_to_keep(pattern, "pos2_641_783", 1, n_Conv3176_683, n_Sub3208_484, 62, e_pos2_641);
+       ext_grs_edge_t *e_e501_784 = ext_grs_act_add_edge_to_keep(pattern, "e501_784", ext_grs_NO_EDGE_POS, n_Add3153_632, n_Add3240_574, 63, e_e501);
+       ext_grs_edge_t *e_e708_785 = ext_grs_act_add_edge_to_keep(pattern, "e708_785", ext_grs_NO_EDGE_POS, n_Phi2663_602, n_Add2631_674, 64, e_e708);
+       ext_grs_edge_t *e_e702_786 = ext_grs_act_add_edge_to_keep(pattern, "e702_786", ext_grs_NO_EDGE_POS, n_Proj2399_601, n_Block2377_553, 65, e_e702);
+       ext_grs_edge_t *e_e701_787 = ext_grs_act_add_edge_to_keep(pattern, "e701_787", ext_grs_NO_EDGE_POS, n_Sub3669_485, n_Phi3707_456, 66, e_e701);
+       ext_grs_edge_t *e_pos0_306_788 = ext_grs_act_add_edge_to_keep(pattern, "pos0_306_788", -1, n_Block3708_590, n_VProj290_627, 67, e_pos0_306);
+       ext_grs_edge_t *e_e704_789 = ext_grs_act_add_edge_to_keep(pattern, "e704_789", ext_grs_NO_EDGE_POS, n_Block2925_571, n_Phi3011_718, 68, e_e704);
+       ext_grs_edge_t *e_e700_790 = ext_grs_act_add_edge_to_keep(pattern, "e700_790", ext_grs_NO_EDGE_POS, n_Sub3643_453, n_Phi3707_456, 69, e_e700);
+       ext_grs_edge_t *e_pos0_505_791 = ext_grs_act_add_edge_to_keep(pattern, "pos0_505_791", -1, n_Block2459_572, n_Jmp2539_450, 70, e_pos0_505);
+       ext_grs_edge_t *e_pos0_506_792 = ext_grs_act_add_edge_to_keep(pattern, "pos0_506_792", -1, n_Block3677_491, n_Sub3756_445, 71, e_pos0_506);
+       ext_grs_edge_t *e_pos2_745_793 = ext_grs_act_add_edge_to_keep(pattern, "pos2_745_793", 1, n_Conv3253_515, n_Sub3321_452, 72, e_pos2_745);
+       ext_grs_edge_t *e_pos2_747_794 = ext_grs_act_add_edge_to_keep(pattern, "pos2_747_794", 1, n_Conv2915_439, n_Cmp5651_597, 73, e_pos2_747);
+       ext_grs_edge_t *e_pos0_406_795 = ext_grs_act_add_edge_to_keep(pattern, "pos0_406_795", -1, n_Block3708_590, n_Add3501_658, 74, e_pos0_406);
+       ext_grs_edge_t *e_e656_796 = ext_grs_act_add_edge_to_keep(pattern, "e656_796", ext_grs_NO_EDGE_POS, n_Phi2837_527, n_Add2805_687, 76, e_e656);
+       ext_grs_edge_t *e_e305_797 = ext_grs_act_add_edge_to_keep(pattern, "e305_797", ext_grs_NO_EDGE_POS, n_Sub2452_655, n_Phi2489_467, 78, e_e305);
+       ext_grs_edge_t *e_e442_798 = ext_grs_act_add_edge_to_keep(pattern, "e442_798", ext_grs_NO_EDGE_POS, n_Proj3354_643, n_Block3329_435, 79, e_e442);
+       ext_grs_edge_t *e_e303_799 = ext_grs_act_add_edge_to_keep(pattern, "e303_799", ext_grs_NO_EDGE_POS, n_Block2404_719, n_Phi2489_467, 80, e_e303);
+       ext_grs_edge_t *e_e304_800 = ext_grs_act_add_edge_to_keep(pattern, "e304_800", ext_grs_NO_EDGE_POS, n_Sub2426_584, n_Phi2489_467, 81, e_e304);
+       ext_grs_edge_t *e_e657_801 = ext_grs_act_add_edge_to_keep(pattern, "e657_801", ext_grs_NO_EDGE_POS, n_Add2718_703, n_Add2805_687, 82, e_e657);
+       ext_grs_edge_t *e_pos2_592_802 = ext_grs_act_add_edge_to_keep(pattern, "pos2_592_802", 1, n_Conv2644_512, n_Sub2712_631, 83, e_pos2_592);
+       ext_grs_edge_t *e_e300_803 = ext_grs_act_add_edge_to_keep(pattern, "e300_803", ext_grs_NO_EDGE_POS, n_Sub2799_488, n_Phi2837_527, 84, e_e300);
+       ext_grs_edge_t *e_e716_804 = ext_grs_act_add_edge_to_keep(pattern, "e716_804", ext_grs_NO_EDGE_POS, n_Jmp3235_629, n_Block3186_551, 85, e_e716);
+       ext_grs_edge_t *e_e448_805 = ext_grs_act_add_edge_to_keep(pattern, "e448_805", ext_grs_NO_EDGE_POS, n_Proj3268_611, n_Block3241_529, 86, e_e448);
+       ext_grs_edge_t *e_e715_806 = ext_grs_act_add_edge_to_keep(pattern, "e715_806", ext_grs_NO_EDGE_POS, n_Jmp3209_501, n_Block3186_551, 87, e_e715);
+       ext_grs_edge_t *e_pos2_393_807 = ext_grs_act_add_edge_to_keep(pattern, "pos2_393_807", 1, n_Conv2741_656, n_Sub2773_522, 88, e_pos2_393);
+       ext_grs_edge_t *e_e712_808 = ext_grs_act_add_edge_to_keep(pattern, "e712_808", ext_grs_NO_EDGE_POS, n_Sub3321_452, n_Phi3359_635, 89, e_e712);
+       ext_grs_edge_t *e_e711_809 = ext_grs_act_add_edge_to_keep(pattern, "e711_809", ext_grs_NO_EDGE_POS, n_Sub3295_619, n_Phi3359_635, 90, e_e711);
+       ext_grs_edge_t *e_e710_810 = ext_grs_act_add_edge_to_keep(pattern, "e710_810", ext_grs_NO_EDGE_POS, n_Block3273_516, n_Phi3359_635, 91, e_e710);
+       ext_grs_edge_t *e_pos2_635_811 = ext_grs_act_add_edge_to_keep(pattern, "pos2_635_811", 1, n_Conv2828_449, n_Sub2860_693, 92, e_pos2_635);
+       ext_grs_edge_t *e_pos1_291_812 = ext_grs_act_add_edge_to_keep(pattern, "pos1_291_812", 0, n_VProj3165_644, n_Conv3166_705, 94, e_pos1_291);
+       ext_grs_edge_t *e_pos2_737_813 = ext_grs_act_add_edge_to_keep(pattern, "pos2_737_813", 1, n_Conv3601_610, n_Sub3669_485, 93, e_pos2_737);
+       ext_grs_edge_t *e_pos1_293_814 = ext_grs_act_add_edge_to_keep(pattern, "pos1_293_814", 0, n_Cond2398_585, n_Proj2399_601, 95, e_pos1_293);
+       ext_grs_edge_t *e_pos1_294_815 = ext_grs_act_add_edge_to_keep(pattern, "pos1_294_815", 0, n_Arg_0_507, n_VProj3426_495, 96, e_pos1_294);
+       ext_grs_edge_t *e_pos2_398_816 = ext_grs_act_add_edge_to_keep(pattern, "pos2_398_816", 1, n_Conv3089_454, n_Sub3121_455, 97, e_pos2_398);
+       ext_grs_edge_t *e_pos1_297_817 = ext_grs_act_add_edge_to_keep(pattern, "pos1_297_817", 0, n_VProj2556_670, n_Conv2557_624, 98, e_pos1_297);
+       ext_grs_edge_t *e_pos2_661_818 = ext_grs_act_add_edge_to_keep(pattern, "pos2_661_818", 1, n_Conv2654_525, n_Cmp5648_565, 99, e_pos2_661);
+       ext_grs_edge_t *e_pos0_564_819 = ext_grs_act_add_edge_to_keep(pattern, "pos0_564_819", -1, n_Block3708_590, n_Add3066_534, 100, e_pos0_564);
+       ext_grs_edge_t *e_e478_820 = ext_grs_act_add_edge_to_keep(pattern, "e478_820", ext_grs_NO_EDGE_POS, n_Sub3556_432, n_Phi3620_433, 101, e_e478);
+       ext_grs_edge_t *e_e477_821 = ext_grs_act_add_edge_to_keep(pattern, "e477_821", ext_grs_NO_EDGE_POS, n_Block3534_561, n_Phi3620_433, 102, e_e477);
+       ext_grs_edge_t *e_e479_822 = ext_grs_act_add_edge_to_keep(pattern, "e479_822", ext_grs_NO_EDGE_POS, n_Sub3582_698, n_Phi3620_433, 104, e_e479);
+       ext_grs_edge_t *e_pos0_568_823 = ext_grs_act_add_edge_to_keep(pattern, "pos0_568_823", -1, n_Block3676_492, n_Jmp3731_519, 103, e_pos0_568);
+       ext_grs_edge_t *e_pos0_426_824 = ext_grs_act_add_edge_to_keep(pattern, "pos0_426_824", -1, n_Block3241_529, n_Jmp3296_671, 105, e_pos0_426);
+       ext_grs_edge_t *e_pos0_694_825 = ext_grs_act_add_edge_to_keep(pattern, "pos0_694_825", -1, n_Block2458_568, n_Sub2512_566, 106, e_pos0_694);
+       ext_grs_edge_t *e_pos0_424_826 = ext_grs_act_add_edge_to_keep(pattern, "pos0_424_826", -1, n_Block3502_709, n_Jmp3557_625, 107, e_pos0_424);
+       ext_grs_edge_t *e_pos0_562_827 = ext_grs_act_add_edge_to_keep(pattern, "pos0_562_827", -1, n_Block3416_604, n_Jmp3496_680, 108, e_pos0_562);
+       ext_grs_edge_t *e_pos0_560_828 = ext_grs_act_add_edge_to_keep(pattern, "pos0_560_828", -1, n_Block3273_516, n_Cond3353_640, 109, e_pos0_560);
+       ext_grs_edge_t *e_pos1_389_829 = ext_grs_act_add_edge_to_keep(pattern, "pos1_389_829", 0, n_Proj3091_540, n_Cond3092_576, 110, e_pos1_389);
+       ext_grs_edge_t *e_pos1_387_830 = ext_grs_act_add_edge_to_keep(pattern, "pos1_387_830", 0, n_Proj3613_690, n_Cond3614_613, 111, e_pos1_387);
+       ext_grs_edge_t *e_pos0_429_831 = ext_grs_act_add_edge_to_keep(pattern, "pos0_429_831", -1, n_Block3708_590, n_Add3414_646, 112, e_pos0_429);
+       ext_grs_edge_t *e_pos1_381_832 = ext_grs_act_add_edge_to_keep(pattern, "pos1_381_832", 0, n_VProj2479_489, n_Conv2480_591, 113, e_pos1_381);
+       ext_grs_edge_t *e_pos1_380_833 = ext_grs_act_add_edge_to_keep(pattern, "pos1_380_833", 0, n_Proj2569_682, n_Cond2570_505, 114, e_pos1_380);
+       ext_grs_edge_t *e_pos1_384_834 = ext_grs_act_add_edge_to_keep(pattern, "pos1_384_834", 0, n_Conv3427_639, n_Sub3469_667, 115, e_pos1_384);
+       ext_grs_edge_t *e_e364_835 = ext_grs_act_add_edge_to_keep(pattern, "e364_835", ext_grs_NO_EDGE_POS, n_Add3501_658, n_Add3588_511, 116, e_e364);
+       ext_grs_edge_t *e_e363_836 = ext_grs_act_add_edge_to_keep(pattern, "e363_836", ext_grs_NO_EDGE_POS, n_Phi3620_433, n_Add3588_511, 117, e_e363);
+       ext_grs_edge_t *e_e465_837 = ext_grs_act_add_edge_to_keep(pattern, "e465_837", ext_grs_NO_EDGE_POS, n_Sub3408_653, n_Phi3446_702, 118, e_e465);
+       ext_grs_edge_t *e_e464_838 = ext_grs_act_add_edge_to_keep(pattern, "e464_838", ext_grs_NO_EDGE_POS, n_Sub3382_545, n_Phi3446_702, 119, e_e464);
+       ext_grs_edge_t *e_pos2_339_839 = ext_grs_act_add_edge_to_keep(pattern, "pos2_339_839", 1, n_Conv3089_454, n_Cmp5653_595, 121, e_pos2_339);
+       ext_grs_edge_t *e_e463_840 = ext_grs_act_add_edge_to_keep(pattern, "e463_840", ext_grs_NO_EDGE_POS, n_Block3360_503, n_Phi3446_702, 120, e_e463);
+       ext_grs_edge_t *e_e461_841 = ext_grs_act_add_edge_to_keep(pattern, "e461_841", ext_grs_NO_EDGE_POS, n_Sub3060_699, n_Phi3098_497, 122, e_e461);
+       ext_grs_edge_t *e_e460_842 = ext_grs_act_add_edge_to_keep(pattern, "e460_842", ext_grs_NO_EDGE_POS, n_Sub3034_444, n_Phi3098_497, 123, e_e460);
+       ext_grs_edge_t *e_pos1_375_843 = ext_grs_act_add_edge_to_keep(pattern, "pos1_375_843", 0, n_Conv2395_549, n_Sub2452_655, 124, e_pos1_375);
+       ext_grs_edge_t *e_pos1_378_844 = ext_grs_act_add_edge_to_keep(pattern, "pos1_378_844", 0, n_Proj3178_430, n_Cond3179_514, 125, e_pos1_378);
+       ext_grs_edge_t *e_pos2_337_845 = ext_grs_act_add_edge_to_keep(pattern, "pos2_337_845", 1, n_Conv2731_678, n_Sub2799_488, 126, e_pos2_337);
+       ext_grs_edge_t *e_pos0_419_846 = ext_grs_act_add_edge_to_keep(pattern, "pos0_419_846", -1, n_Block3329_435, n_Jmp3409_499, 127, e_pos0_419);
+       ext_grs_edge_t *e_pos1_370_847 = ext_grs_act_add_edge_to_keep(pattern, "pos1_370_847", 0, n_Conv3253_515, n_Sub3295_619, 128, e_pos1_370);
+       ext_grs_edge_t *e_pos1_372_848 = ext_grs_act_add_edge_to_keep(pattern, "pos1_372_848", 0, n_Conv3166_705, n_Cmp5654_594, 129, e_pos1_372);
+       ext_grs_edge_t *e_e352_849 = ext_grs_act_add_edge_to_keep(pattern, "e352_849", ext_grs_NO_EDGE_POS, n_Jmp3409_499, n_Block3360_503, 130, e_e352);
+       ext_grs_edge_t *e_pos0_543_850 = ext_grs_act_add_edge_to_keep(pattern, "pos0_543_850", -1, n_Block3155_618, n_Sub3234_431, 131, e_pos0_543);
+       ext_grs_edge_t *e_e351_851 = ext_grs_act_add_edge_to_keep(pattern, "e351_851", ext_grs_NO_EDGE_POS, n_Jmp3383_562, n_Block3360_503, 132, e_e351);
+       ext_grs_edge_t *e_pos0_542_852 = ext_grs_act_add_edge_to_keep(pattern, "pos0_542_852", -1, n_Block3328_436, n_Jmp3383_562, 134, e_pos0_542);
+       ext_grs_edge_t *e_pos2_685_853 = ext_grs_act_add_edge_to_keep(pattern, "pos2_685_853", 1, n_Conv2741_656, n_Cmp5649_567, 133, e_pos2_685);
+       ext_grs_edge_t *e_pos0_444_854 = ext_grs_act_add_edge_to_keep(pattern, "pos0_444_854", -1, n_Block2545_633, n_Sub2599_651, 136, e_pos0_444);
+       ext_grs_edge_t *e_e492_855 = ext_grs_act_add_edge_to_keep(pattern, "e492_855", ext_grs_NO_EDGE_POS, n_Sub3208_484, n_Phi3272_673, 135, e_e492);
+       ext_grs_edge_t *e_e491_856 = ext_grs_act_add_edge_to_keep(pattern, "e491_856", ext_grs_NO_EDGE_POS, n_Block3186_551, n_Phi3272_673, 137, e_e491);
+       ext_grs_edge_t *e_e494_857 = ext_grs_act_add_edge_to_keep(pattern, "e494_857", ext_grs_NO_EDGE_POS, n_Proj2659_623, n_Block2632_606, 138, e_e494);
+       ext_grs_edge_t *e_e493_858 = ext_grs_act_add_edge_to_keep(pattern, "e493_858", ext_grs_NO_EDGE_POS, n_Sub3234_431, n_Phi3272_673, 140, e_e493);
+       ext_grs_edge_t *e_e600_859 = ext_grs_act_add_edge_to_keep(pattern, "e600_859", ext_grs_NO_EDGE_POS, n_Proj2920_535, n_Block2893_518, 139, e_e600);
+       ext_grs_edge_t *e_pos0_449_860 = ext_grs_act_add_edge_to_keep(pattern, "pos0_449_860", -1, n_Block2632_606, n_Jmp2687_677, 142, e_pos0_449);
+       ext_grs_edge_t *e_e495_861 = ext_grs_act_add_edge_to_keep(pattern, "e495_861", ext_grs_NO_EDGE_POS, n_Proj2658_622, n_Block2633_615, 141, e_e495);
+       ext_grs_edge_t *e_e498_862 = ext_grs_act_add_edge_to_keep(pattern, "e498_862", ext_grs_NO_EDGE_POS, n_Jmp3496_680, n_Block3447_539, 143, e_e498);
+       ext_grs_edge_t *e_e497_863 = ext_grs_act_add_edge_to_keep(pattern, "e497_863", ext_grs_NO_EDGE_POS, n_Jmp3470_710, n_Block3447_539, 144, e_e497);
+       ext_grs_edge_t *e_e606_864 = ext_grs_act_add_edge_to_keep(pattern, "e606_864", ext_grs_NO_EDGE_POS, n_Proj2832_486, n_Block2807_681, 145, e_e606);
+       ext_grs_edge_t *e_pos2_368_865 = ext_grs_act_add_edge_to_keep(pattern, "pos2_368_865", 1, n_Conv2915_439, n_Sub2947_558, 146, e_pos2_368);
+       ext_grs_edge_t *e_pos2_361_866 = ext_grs_act_add_edge_to_keep(pattern, "pos2_361_866", 1, n_Conv3611_636, n_Sub3643_453, 147, e_pos2_361);
+       ext_grs_edge_t *e_e489_867 = ext_grs_act_add_edge_to_keep(pattern, "e489_867", ext_grs_NO_EDGE_POS, n_Sub2860_693, n_Phi2924_526, 149, e_e489);
+       ext_grs_edge_t *e_pos0_536_868 = ext_grs_act_add_edge_to_keep(pattern, "pos0_536_868", -1, n_Block2807_681, n_Sub2886_434, 148, e_pos0_536);
+       ext_grs_edge_t *e_e488_869 = ext_grs_act_add_edge_to_keep(pattern, "e488_869", ext_grs_NO_EDGE_POS, n_Block2838_630, n_Phi2924_526, 150, e_e488);
+       ext_grs_edge_t *e_pos2_674_870 = ext_grs_act_add_edge_to_keep(pattern, "pos2_674_870", 1, n_Conv2654_525, n_Sub2686_446, 151, e_pos2_674);
+       ext_grs_edge_t *e_pos0_532_871 = ext_grs_act_add_edge_to_keep(pattern, "pos0_532_871", -1, n_Block3503_708, n_Sub3582_698, 152, e_pos0_532);
+       ext_grs_edge_t *e_e346_872 = ext_grs_act_add_edge_to_keep(pattern, "e346_872", ext_grs_NO_EDGE_POS, n_Proj3442_458, n_Block3415_603, 153, e_e346);
+       ext_grs_edge_t *e_pos0_439_873 = ext_grs_act_add_edge_to_keep(pattern, "pos0_439_873", -1, n_Block3447_539, n_Cond3527_441, 154, e_pos0_439);
+       ext_grs_edge_t *e_e617_874 = ext_grs_act_add_edge_to_keep(pattern, "e617_874", ext_grs_NO_EDGE_POS, n_Jmp3644_715, n_Block3621_533, 155, e_e617);
+       ext_grs_edge_t *e_e618_875 = ext_grs_act_add_edge_to_keep(pattern, "e618_875", ext_grs_NO_EDGE_POS, n_Jmp3670_578, n_Block3621_533, 156, e_e618);
+       ext_grs_edge_t *e_pos1_397_876 = ext_grs_act_add_edge_to_keep(pattern, "pos1_397_876", 0, n_Conv3079_686, n_Sub3121_455, 158, e_pos1_397);
+       ext_grs_edge_t *e_e490_877 = ext_grs_act_add_edge_to_keep(pattern, "e490_877", ext_grs_NO_EDGE_POS, n_Sub2886_434, n_Phi2924_526, 157, e_e490);
+       ext_grs_edge_t *e_pos2_350_878 = ext_grs_act_add_edge_to_keep(pattern, "pos2_350_878", 1, n_Conv2557_624, n_Sub2625_616, 160, e_pos2_350);
+       ext_grs_edge_t *e_pos1_394_879 = ext_grs_act_add_edge_to_keep(pattern, "pos1_394_879", 0, n_Arg_0_507, n_VProj3513_465, 159, e_pos1_394);
+       ext_grs_edge_t *e_pos0_539_880 = ext_grs_act_add_edge_to_keep(pattern, "pos0_539_880", -1, n_Block3708_590, n_Add3153_632, 161, e_pos0_539);
+       ext_grs_edge_t *e_pos1_392_881 = ext_grs_act_add_edge_to_keep(pattern, "pos1_392_881", 0, n_Conv2731_678, n_Sub2773_522, 162, e_pos1_392);
+       ext_grs_edge_t *e_pos1_340_882 = ext_grs_act_add_edge_to_keep(pattern, "pos1_340_882", 0, n_Arg_1_509, n_VProj2740_524, 163, e_pos1_340);
+       ext_grs_edge_t *e_pos1_341_883 = ext_grs_act_add_edge_to_keep(pattern, "pos1_341_883", 0, n_Cmp5650_598, n_Proj2830_487, 164, e_pos1_341);
+       ext_grs_edge_t *e_pos1_342_884 = ext_grs_act_add_edge_to_keep(pattern, "pos1_342_884", 0, n_Cond3092_576, n_Proj3094_537, 165, e_pos1_342);
+       ext_grs_edge_t *e_pos1_343_885 = ext_grs_act_add_edge_to_keep(pattern, "pos1_343_885", 0, n_Cond2483_560, n_Proj2485_666, 166, e_pos1_343);
+       ext_grs_edge_t *e_pos1_345_886 = ext_grs_act_add_edge_to_keep(pattern, "pos1_345_886", 0, n_Cond3527_441, n_Proj3529_700, 167, e_pos1_345);
+       ext_grs_edge_t *e_pos1_347_887 = ext_grs_act_add_edge_to_keep(pattern, "pos1_347_887", 0, n_Cond3005_659, n_Proj3007_665, 169, e_pos1_347);
+       ext_grs_edge_t *e_pos1_626_888 = ext_grs_act_add_edge_to_keep(pattern, "pos1_626_888", 0, n_Arg_1_509, n_VProj3697_626, 168, e_pos1_626);
+       ext_grs_edge_t *e_pos1_349_889 = ext_grs_act_add_edge_to_keep(pattern, "pos1_349_889", 0, n_Conv2567_647, n_Sub2625_616, 171, e_pos1_349);
+       ext_grs_edge_t *e_pos1_628_890 = ext_grs_act_add_edge_to_keep(pattern, "pos1_628_890", 0, n_Conv3514_502, n_Sub3556_432, 170, e_pos1_628);
+       ext_grs_edge_t *e_pos1_622_891 = ext_grs_act_add_edge_to_keep(pattern, "pos1_622_891", 0, n_Arg_0_507, n_VProj2385_438, 172, e_pos1_622);
+       ext_grs_edge_t *e_pos0_468_892 = ext_grs_act_add_edge_to_keep(pattern, "pos0_468_892", -1, n_Block2376_552, n_Sub2426_584, 173, e_pos0_468);
+       ext_grs_edge_t *e_pos1_623_893 = ext_grs_act_add_edge_to_keep(pattern, "pos1_623_893", 0, n_Arg_1_509, n_VProj2653_447, 174, e_pos1_623);
+       ext_grs_edge_t *e_pos1_620_894 = ext_grs_act_add_edge_to_keep(pattern, "pos1_620_894", 0, n_Conv2480_591, n_Sub2538_617, 175, e_pos1_620);
+       ext_grs_edge_t *e_pos0_655_895 = ext_grs_act_add_edge_to_keep(pattern, "pos0_655_895", -1, n_Block3708_590, n_Add2805_687, 176, e_pos0_655);
+       ext_grs_edge_t *e_pos0_462_896 = ext_grs_act_add_edge_to_keep(pattern, "pos0_462_896", -1, n_Block2806_676, n_Jmp2861_538, 177, e_pos0_462);
+       ext_grs_edge_t *e_pos0_651_897 = ext_grs_act_add_edge_to_keep(pattern, "pos0_651_897", -1, n_Block3360_503, n_Cond3440_459, 178, e_pos0_651);
+       ext_grs_edge_t *e_pos1_757_898 = ext_grs_act_add_edge(pattern, "pos1_757_898", 0, n_Vector_op_ProjData, n_VProj290_627, 463);
+       ext_grs_edge_t *e_pos1_333_899 = ext_grs_act_add_edge_to_keep(pattern, "pos1_333_899", 0, n_Arg_1_509, n_VProj3001_641, 179, e_pos1_333);
+       ext_grs_edge_t *e_pos0_390_900 = ext_grs_act_add_edge_to_keep(pattern, "pos0_390_900", -1, n_Block2894_517, n_Jmp2974_523, 180, e_pos0_390);
+       ext_grs_edge_t *e_pos0_391_901 = ext_grs_act_add_edge_to_keep(pattern, "pos0_391_901", -1, n_Block2719_573, n_Sub2773_522, 181, e_pos0_391);
+       ext_grs_edge_t *e_pos0_396_902 = ext_grs_act_add_edge_to_keep(pattern, "pos0_396_902", -1, n_Block3067_506, n_Sub3121_455, 183, e_pos0_396);
+       ext_grs_edge_t *e_pos1_616_903 = ext_grs_act_add_edge_to_keep(pattern, "pos1_616_903", 0, n_VProj2730_542, n_Conv2731_678, 182, e_pos1_616);
+       ext_grs_edge_t *e_pos1_338_904 = ext_grs_act_add_edge_to_keep(pattern, "pos1_338_904", 0, n_Conv3079_686, n_Cmp5653_595, 184, e_pos1_338);
+       ext_grs_edge_t *e_pos1_336_905 = ext_grs_act_add_edge_to_keep(pattern, "pos1_336_905", 0, n_Conv2741_656, n_Sub2799_488, 186, e_pos1_336);
+       ext_grs_edge_t *e_pos1_615_906 = ext_grs_act_add_edge_to_keep(pattern, "pos1_615_906", 0, n_Arg_1_509, n_VProj3262_717, 185, e_pos1_615);
+       ext_grs_edge_t *e_pos1_613_907 = ext_grs_act_add_edge_to_keep(pattern, "pos1_613_907", 0, n_Conv3340_580, n_Sub3382_545, 187, e_pos1_613);
+       ext_grs_edge_t *e_pos0_590_908 = ext_grs_act_add_edge_to_keep(pattern, "pos0_590_908", -1, n_Block2633_615, n_Sub2712_631, 188, e_pos0_590);
+       ext_grs_edge_t *e_pos1_610_909 = ext_grs_act_add_edge_to_keep(pattern, "pos1_610_909", 0, n_VProj2394_451, n_Conv2395_549, 189, e_pos1_610);
+       ext_grs_edge_t *e_pos0_594_910 = ext_grs_act_add_edge_to_keep(pattern, "pos0_594_910", -1, n_Block3708_590, n_Add2979_504, 190, e_pos0_594);
+       ext_grs_edge_t *e_pos0_455_911 = ext_grs_act_add_edge_to_keep(pattern, "pos0_455_911", -1, n_Block3708_590, n_Add3327_556, 191, e_pos0_455);
+       ext_grs_edge_t *e_pos1_751_912 = ext_grs_act_add_edge_to_keep(pattern, "pos1_751_912", 0, n_Cond3005_659, n_Proj3006_664, 192, e_pos1_751);
+       ext_grs_edge_t *e_pos1_750_913 = ext_grs_act_add_edge_to_keep(pattern, "pos1_750_913", 0, n_Proj2482_660, n_Cond2483_560, 193, e_pos1_750);
+       ext_grs_edge_t *e_pos0_667_914 = ext_grs_act_add_edge_to_keep(pattern, "pos0_667_914", -1, n_Block2981_692, n_Jmp3061_448, 194, e_pos0_667);
+       ext_grs_edge_t *e_pos0_597_915 = ext_grs_act_add_edge_to_keep(pattern, "pos0_597_915", -1, n_Block2838_630, n_Cond2918_588, 195, e_pos0_597);
+       ext_grs_edge_t *e_pos0_450_916 = ext_grs_act_add_edge_to_keep(pattern, "pos0_450_916", -1, n_Block2633_615, n_Jmp2713_544, 196, e_pos0_450);
+       ext_grs_edge_t *e_pos1_755_917 = ext_grs_act_add_edge(pattern, "pos1_755_917", 0, n_Arg_0_507, n_Vector_op, 464);
+       ext_grs_edge_t *e_pos1_754_918 = ext_grs_act_add_edge(pattern, "pos1_754_918", 0, n_Vector_op, n_Vector_op_ProjData, 465);
+       ext_grs_edge_t *e_pos0_663_919 = ext_grs_act_add_edge_to_keep(pattern, "pos0_663_919", -1, n_Block2719_573, n_Jmp2774_663, 197, e_pos0_663);
+       ext_grs_edge_t *e_pos0_662_920 = ext_grs_act_add_edge_to_keep(pattern, "pos0_662_920", -1, n_Block3590_547, n_Jmp3670_578, 198, e_pos0_662);
+       ext_grs_edge_t *e_pos1_360_921 = ext_grs_act_add_edge_to_keep(pattern, "pos1_360_921", 0, n_Conv3601_610, n_Sub3643_453, 199, e_pos1_360);
+       ext_grs_edge_t *e_pos1_746_922 = ext_grs_act_add_edge_to_keep(pattern, "pos1_746_922", 0, n_Conv2905_548, n_Cmp5651_597, 200, e_pos1_746);
+       ext_grs_edge_t *e_pos0_388_923 = ext_grs_act_add_edge_to_keep(pattern, "pos0_388_923", -1, n_Block3012_628, n_Cond3092_576, 201, e_pos0_388);
+       ext_grs_edge_t *e_pos1_748_924 = ext_grs_act_add_edge_to_keep(pattern, "pos1_748_924", 0, n_Cond2744_642, n_Proj2746_712, 202, e_pos1_748);
+       ext_grs_edge_t *e_pos1_647_925 = ext_grs_act_add_edge_to_keep(pattern, "pos1_647_925", 0, n_Arg_0_507, n_VProj2730_542, 203, e_pos1_647);
+       ext_grs_edge_t *e_pos0_383_926 = ext_grs_act_add_edge_to_keep(pattern, "pos0_383_926", -1, n_Block3415_603, n_Sub3469_667, 204, e_pos0_383);
+       ext_grs_edge_t *e_pos0_386_927 = ext_grs_act_add_edge_to_keep(pattern, "pos0_386_927", -1, n_Block3534_561, n_Cond3614_613, 205, e_pos0_386);
+       ext_grs_edge_t *e_pos1_367_928 = ext_grs_act_add_edge_to_keep(pattern, "pos1_367_928", 0, n_Conv2905_548, n_Sub2947_558, 206, e_pos1_367);
+       ext_grs_edge_t *e_pos1_640_929 = ext_grs_act_add_edge_to_keep(pattern, "pos1_640_929", 0, n_Conv3166_705, n_Sub3208_484, 207, e_pos1_640);
+       ext_grs_edge_t *e_e585_930 = ext_grs_act_add_edge_to_keep(pattern, "e585_930", ext_grs_NO_EDGE_POS, n_Jmp2626_464, n_Block2577_685, 208, e_e585);
+       ext_grs_edge_t *e_pos0_581_931 = ext_grs_act_add_edge_to_keep(pattern, "pos0_581_931", -1, n_Block2664_581, n_Cond2744_642, 209, e_pos0_581);
+       ext_grs_edge_t *e_pos1_642_932 = ext_grs_act_add_edge_to_keep(pattern, "pos1_642_932", 0, n_Cmp5651_597, n_Proj2917_531, 210, e_pos1_642);
+       ext_grs_edge_t *e_e584_933 = ext_grs_act_add_edge_to_keep(pattern, "e584_933", ext_grs_NO_EDGE_POS, n_Jmp2600_498, n_Block2577_685, 211, e_e584);
+       ext_grs_edge_t *e_pos1_643_934 = ext_grs_act_add_edge_to_keep(pattern, "pos1_643_934", 0, n_Conv2557_624, n_Cmp5647_564, 212, e_pos1_643);
+       ext_grs_edge_t *e_pos0_672_935 = ext_grs_act_add_edge_to_keep(pattern, "pos0_672_935", -1, n_Block2632_606, n_Sub2686_446, 213, e_pos0_672);
+       ext_grs_edge_t *e_pos1_646_936 = ext_grs_act_add_edge_to_keep(pattern, "pos1_646_936", 0, n_Arg_1_509, n_VProj2394_451, 214, e_pos1_646);
+       ext_grs_edge_t *e_pos0_671_937 = ext_grs_act_add_edge_to_keep(pattern, "pos0_671_937", -1, n_Block2377_553, n_Jmp2453_555, 215, e_pos0_671);
+       ext_grs_edge_t *e_pos1_742_938 = ext_grs_act_add_edge_to_keep(pattern, "pos1_742_938", 0, n_Cond3614_613, n_Proj3615_694, 216, e_pos1_742);
+       ext_grs_edge_t *e_pos0_481_939 = ext_grs_act_add_edge_to_keep(pattern, "pos0_481_939", -1, n_Block2577_685, n_Cond2657_577, 217, e_pos0_481);
+       ext_grs_edge_t *e_pos1_744_940 = ext_grs_act_add_edge_to_keep(pattern, "pos1_744_940", 0, n_Conv3263_532, n_Sub3321_452, 218, e_pos1_744);
+       ext_grs_edge_t *e_pos0_675_941 = ext_grs_act_add_edge_to_keep(pattern, "pos0_675_941", -1, n_Block3708_590, n_Add2718_703, 219, e_pos0_675);
+       ext_grs_edge_t *e_pos0_678_942 = ext_grs_act_add_edge_to_keep(pattern, "pos0_678_942", -1, n_Block2925_571, n_Cond3005_659, 220, e_pos0_678);
+       ext_grs_edge_t *e_e589_943 = ext_grs_act_add_edge_to_keep(pattern, "e589_943", ext_grs_NO_EDGE_POS, n_Proj3441_457, n_Block3416_604, 221, e_e589);
+       ext_grs_edge_t *e_pos0_483_944 = ext_grs_act_add_edge_to_keep(pattern, "pos0_483_944", -1, n_Block3677_491, n_Jmp3757_605, 222, e_pos0_483);
+       ext_grs_edge_t *e_pos1_740_945 = ext_grs_act_add_edge_to_keep(pattern, "pos1_740_945", 0, n_Conv2915_439, n_Sub2973_679, 223, e_pos1_740);
+       ext_grs_edge_t *e_pos0_484_946 = ext_grs_act_add_edge_to_keep(pattern, "pos0_484_946", -1, n_Block3621_533, n_Cond3701_714, 224, e_pos0_484);
+       ext_grs_edge_t *e_pos0_379_947 = ext_grs_act_add_edge_to_keep(pattern, "pos0_379_947", -1, n_Block2490_521, n_Cond2570_505, 225, e_pos0_379);
+       ext_grs_edge_t *e_pos1_736_948 = ext_grs_act_add_edge_to_keep(pattern, "pos1_736_948", 0, n_Conv3611_636, n_Sub3669_485, 226, e_pos1_736);
+       ext_grs_edge_t *e_pos0_377_949 = ext_grs_act_add_edge_to_keep(pattern, "pos0_377_949", -1, n_Block3099_472, n_Cond3179_514, 227, e_pos0_377);
+       ext_grs_edge_t *e_pos0_374_950 = ext_grs_act_add_edge_to_keep(pattern, "pos0_374_950", -1, n_Block2377_553, n_Sub2452_655, 228, e_pos0_374);
+       ext_grs_edge_t *e_pos1_357_951 = ext_grs_act_add_edge_to_keep(pattern, "pos1_357_951", 0, n_VProj3252_691, n_Conv3253_515, 229, e_pos1_357);
+       ext_grs_edge_t *e_pos1_358_952 = ext_grs_act_add_edge_to_keep(pattern, "pos1_358_952", 0, n_Cond2744_642, n_Proj2745_711, 230, e_pos1_358);
+       ext_grs_edge_t *e_pos1_353_953 = ext_grs_act_add_edge_to_keep(pattern, "pos1_353_953", 0, n_VProj3513_465, n_Conv3514_502, 231, e_pos1_353);
+       ext_grs_edge_t *e_pos1_630_954 = ext_grs_act_add_edge_to_keep(pattern, "pos1_630_954", 0, n_Cond3353_640, n_Proj3355_638, 232, e_pos1_630);
+       ext_grs_edge_t *e_e595_955 = ext_grs_act_add_edge_to_keep(pattern, "e595_955", ext_grs_NO_EDGE_POS, n_Phi3011_718, n_Add2979_504, 233, e_e595);
+       ext_grs_edge_t *e_e596_956 = ext_grs_act_add_edge_to_keep(pattern, "e596_956", ext_grs_NO_EDGE_POS, n_Add2892_554, n_Add2979_504, 234, e_e596);
+       ext_grs_edge_t *e_pos0_571_957 = ext_grs_act_add_edge_to_keep(pattern, "pos0_571_957", -1, n_Block2893_518, n_Jmp2948_442, 235, e_pos0_571);
+       ext_grs_edge_t *e_pos1_634_958 = ext_grs_act_add_edge_to_keep(pattern, "pos1_634_958", 0, n_Conv2818_437, n_Sub2860_693, 236, e_pos1_634);
+       ext_grs_edge_t *e_pos1_730_959 = ext_grs_act_add_edge_to_keep(pattern, "pos1_730_959", 0, n_VProj3436_546, n_Conv3437_614, 237, e_pos1_730);
+       ext_grs_edge_t *e_pos0_577_960 = ext_grs_act_add_edge_to_keep(pattern, "pos0_577_960", -1, n_Block2807_681, n_Jmp2887_500, 238, e_pos0_577);
+       ext_grs_edge_t *e_e599_961 = ext_grs_act_add_edge_to_keep(pattern, "e599_961", ext_grs_NO_EDGE_POS, n_Proj3703_468, n_Block3676_492, 239, e_e599);
+       ext_grs_edge_t *e_pos0_471_962 = ext_grs_act_add_edge_to_keep(pattern, "pos0_471_962", -1, n_Block3186_551, n_Cond3266_543, 240, e_pos0_471);
+       ext_grs_edge_t *e_pos2_728_963 = ext_grs_act_add_edge_to_keep(pattern, "pos2_728_963", 1, n_Conv3427_639, n_Sub3495_648, 241, e_pos2_728);
+       ext_grs_edge_t *e_pos1_301_964 = ext_grs_act_add_edge_to_keep(pattern, "pos1_301_964", 0, n_VProj3600_510, n_Conv3601_610, 242, e_pos1_301);
+       ext_grs_edge_t *e_pos0_362_965 = ext_grs_act_add_edge_to_keep(pattern, "pos0_362_965", -1, n_Block3708_590, n_Add3588_511, 243, e_pos0_362);
+       ext_grs_edge_t *e_pos2_725_966 = ext_grs_act_add_edge_to_keep(pattern, "pos2_725_966", 1, n_Conv3079_686, n_Sub3147_493, 244, e_pos2_725);
+       ext_grs_edge_t *e_pos1_302_967 = ext_grs_act_add_edge_to_keep(pattern, "pos1_302_967", 0, n_VProj3078_654, n_Conv3079_686, 245, e_pos1_302);
+       ext_grs_edge_t *e_pos0_366_968 = ext_grs_act_add_edge_to_keep(pattern, "pos0_366_968", -1, n_Block2893_518, n_Sub2947_558, 246, e_pos0_366);
+       ext_grs_edge_t *e_pos1_724_969 = ext_grs_act_add_edge_to_keep(pattern, "pos1_724_969", 0, n_Conv3089_454, n_Sub3147_493, 247, e_pos1_724);
+       ext_grs_edge_t *e_pos0_619_970 = ext_grs_act_add_edge_to_keep(pattern, "pos0_619_970", -1, n_Block2459_572, n_Sub2538_617, 248, e_pos0_619);
+       ext_grs_edge_t *e_pos0_365_971 = ext_grs_act_add_edge_to_keep(pattern, "pos0_365_971", -1, n_Block3503_708, n_Jmp3583_550, 249, e_pos0_365);
+       ext_grs_edge_t *e_pos1_727_972 = ext_grs_act_add_edge_to_keep(pattern, "pos1_727_972", 0, n_Conv3437_614, n_Sub3495_648, 250, e_pos1_727);
+       ext_grs_edge_t *e_pos1_520_973 = ext_grs_act_add_edge_to_keep(pattern, "pos1_520_973", 0, n_Conv3350_557, n_Sub3408_653, 251, e_pos1_520);
+       ext_grs_edge_t *e_pos1_729_974 = ext_grs_act_add_edge_to_keep(pattern, "pos1_729_974", 0, n_VProj3426_495, n_Conv3427_639, 252, e_pos1_729);
+       ext_grs_edge_t *e_pos1_522_975 = ext_grs_act_add_edge_to_keep(pattern, "pos1_522_975", 0, n_Cmp5655_593, n_Proj3265_608, 253, e_pos1_522);
+       ext_grs_edge_t *e_pos0_369_976 = ext_grs_act_add_edge_to_keep(pattern, "pos0_369_976", -1, n_Block3241_529, n_Sub3295_619, 254, e_pos0_369);
+       ext_grs_edge_t *e_pos1_525_977 = ext_grs_act_add_edge_to_keep(pattern, "pos1_525_977", 0, n_Cond3353_640, n_Proj3354_643, 255, e_pos1_525);
+       ext_grs_edge_t *e_pos0_611_978 = ext_grs_act_add_edge_to_keep(pattern, "pos0_611_978", -1, n_Block3242_530, n_Jmp3322_466, 256, e_pos0_611);
+       ext_grs_edge_t *e_pos0_612_979 = ext_grs_act_add_edge_to_keep(pattern, "pos0_612_979", -1, n_Block3328_436, n_Sub3382_545, 257, e_pos0_612);
+       ext_grs_edge_t *e_pos1_527_980 = ext_grs_act_add_edge_to_keep(pattern, "pos1_527_980", 0, n_Arg_1_509, n_VProj3610_471, 258, e_pos1_527);
+       ext_grs_edge_t *e_e566_981 = ext_grs_act_add_edge_to_keep(pattern, "e566_981", ext_grs_NO_EDGE_POS, n_Add2979_504, n_Add3066_534, 259, e_e566);
+       ext_grs_edge_t *e_pos1_528_982 = ext_grs_act_add_edge_to_keep(pattern, "pos1_528_982", 0, n_Arg_1_509, n_VProj3088_672, 260, e_pos1_528);
+       ext_grs_edge_t *e_e565_983 = ext_grs_act_add_edge_to_keep(pattern, "e565_983", ext_grs_NO_EDGE_POS, n_Phi3098_497, n_Add3066_534, 261, e_e565);
+       ext_grs_edge_t *e_pos1_529_984 = ext_grs_act_add_edge_to_keep(pattern, "pos1_529_984", 0, n_Cmp5648_565, n_Proj2656_621, 262, e_pos1_529);
+       ext_grs_edge_t *e_pos1_720_985 = ext_grs_act_add_edge_to_keep(pattern, "pos1_720_985", 0, n_Cond2398_585, n_Proj2400_496, 263, e_pos1_720);
+       ext_grs_edge_t *e_pos1_721_986 = ext_grs_act_add_edge_to_keep(pattern, "pos1_721_986", 0, n_Cond2570_505, n_Proj2571_661, 264, e_pos1_721);
+       ext_grs_edge_t *e_pos0_752_987 = ext_grs_act_add_edge(pattern, "pos0_752_987", -1, n_Vector_op_Block_706, n_Vector_op, 466);
+       ext_grs_edge_t *e_pos0_753_988 = ext_grs_act_add_edge(pattern, "pos0_753_988", -1, n_Vector_op_Block_706, n_Vector_op_ProjData, 467);
+       ext_grs_edge_t *e_pos1_309_989 = ext_grs_act_add_edge_to_keep(pattern, "pos1_309_989", 0, n_VProj3001_641, n_Conv3002_582, 265, e_pos1_309);
+       ext_grs_edge_t *e_e666_990 = ext_grs_act_add_edge_to_keep(pattern, "e666_990", ext_grs_NO_EDGE_POS, n_Proj2571_661, n_Block2546_634, 266, e_e666);
+       ext_grs_edge_t *e_e563_991 = ext_grs_act_add_edge_to_keep(pattern, "e563_991", ext_grs_NO_EDGE_POS, n_Proj3355_638, n_Block3328_436, 267, e_e563);
+       ext_grs_edge_t *e_e664_992 = ext_grs_act_add_edge_to_keep(pattern, "e664_992", ext_grs_NO_EDGE_POS, n_Proj2400_496, n_Block2376_552, 268, e_e664);
+       ext_grs_edge_t *e_pos2_718_993 = ext_grs_act_add_edge_to_keep(pattern, "pos2_718_993", 1, n_Conv2828_449, n_Cmp5650_598, 269, e_pos2_718);
+       ext_grs_edge_t *e_pos0_356_994 = ext_grs_act_add_edge_to_keep(pattern, "pos0_356_994", -1, n_Block3067_506, n_Jmp3122_612, 270, e_pos0_356);
+       ext_grs_edge_t *e_pos1_714_995 = ext_grs_act_add_edge_to_keep(pattern, "pos1_714_995", 0, n_Cmp5652_596, n_Proj3004_657, 271, e_pos1_714);
+       ext_grs_edge_t *e_pos0_355_996 = ext_grs_act_add_edge_to_keep(pattern, "pos0_355_996", -1, n_Block3589_541, n_Jmp3644_715, 272, e_pos0_355);
+       ext_grs_edge_t *e_pos1_713_997 = ext_grs_act_add_edge_to_keep(pattern, "pos1_713_997", 0, n_Arg_1_509, n_VProj2914_688, 273, e_pos1_713);
+       ext_grs_edge_t *e_pos0_354_998 = ext_grs_act_add_edge_to_keep(pattern, "pos0_354_998", -1, n_Block2545_633, n_Jmp2600_498, 274, e_pos0_354);
+       ext_grs_edge_t *e_pos1_719_999 = ext_grs_act_add_edge_to_keep(pattern, "pos1_719_999", 0, n_Cmp5649_567, n_Proj2743_713, 275, e_pos1_719);
+       ext_grs_edge_t *e_pos1_513_1000 = ext_grs_act_add_edge_to_keep(pattern, "pos1_513_1000", 0, n_Proj2397_600, n_Cond2398_585, 276, e_pos1_513);
+       ext_grs_edge_t *e_pos0_627_1001 = ext_grs_act_add_edge_to_keep(pattern, "pos0_627_1001", -1, n_Block3502_709, n_Sub3556_432, 277, e_pos0_627);
+       ext_grs_edge_t *e_pos0_359_1002 = ext_grs_act_add_edge_to_keep(pattern, "pos0_359_1002", -1, n_Block3589_541, n_Sub3643_453, 278, e_pos0_359);
+       ext_grs_edge_t *e_pos1_717_1003 = ext_grs_act_add_edge_to_keep(pattern, "pos1_717_1003", 0, n_Conv2818_437, n_Cmp5650_598, 279, e_pos1_717);
+       ext_grs_edge_t *e_pos1_511_1004 = ext_grs_act_add_edge_to_keep(pattern, "pos1_511_1004", 0, n_VProj2904_583, n_Conv2905_548, 280, e_pos1_511);
+       ext_grs_edge_t *e_pos1_517_1005 = ext_grs_act_add_edge_to_keep(pattern, "pos1_517_1005", 0, n_Arg_1_509, n_VProj3175_652, 281, e_pos1_517);
+       ext_grs_edge_t *e_pos1_518_1006 = ext_grs_act_add_edge_to_keep(pattern, "pos1_518_1006", 0, n_Arg_1_509, n_VProj2566_480, 282, e_pos1_518);
+       ext_grs_edge_t *e_pos0_496_1007 = ext_grs_act_add_edge_to_keep(pattern, "pos0_496_1007", -1, n_Block3068_508, n_Jmp3148_649, 283, e_pos0_496);
+       ext_grs_edge_t *e_pos1_515_1008 = ext_grs_act_add_edge_to_keep(pattern, "pos1_515_1008", 0, n_Conv3002_582, n_Sub3060_699, 284, e_pos1_515);
+       ext_grs_edge_t *e_e676_1009 = ext_grs_act_add_edge_to_keep(pattern, "e676_1009", ext_grs_NO_EDGE_POS, n_Phi2750_494, n_Add2718_703, 285, e_e676);
+       ext_grs_edge_t *e_e573_1010 = ext_grs_act_add_edge_to_keep(pattern, "e573_1010", ext_grs_NO_EDGE_POS, n_Sub2512_566, n_Phi2576_575, 286, e_e573);
+       ext_grs_edge_t *e_pos0_499_1011 = ext_grs_act_add_edge_to_keep(pattern, "pos0_499_1011", -1, n_Block3708_590, n_Add3240_574, 287, e_pos0_499);
+       ext_grs_edge_t *e_e572_1012 = ext_grs_act_add_edge_to_keep(pattern, "e572_1012", ext_grs_NO_EDGE_POS, n_Block2490_521, n_Phi2576_575, 288, e_e572);
+       ext_grs_edge_t *e_e677_1013 = ext_grs_act_add_edge_to_keep(pattern, "e677_1013", ext_grs_NO_EDGE_POS, n_Add2631_674, n_Add2718_703, 289, e_e677);
+       ext_grs_edge_t *e_e574_1014 = ext_grs_act_add_edge_to_keep(pattern, "e574_1014", ext_grs_NO_EDGE_POS, n_Sub2538_617, n_Phi2576_575, 290, e_e574);
+       ext_grs_edge_t *e_pos1_604_1015 = ext_grs_act_add_edge_to_keep(pattern, "pos1_604_1015", 0, n_Conv2470_579, n_Cmp5646_563, 291, e_pos1_604);
+       ext_grs_edge_t *e_pos1_327_1016 = ext_grs_act_add_edge_to_keep(pattern, "pos1_327_1016", 0, n_Arg_0_507, n_VProj2556_670, 292, e_pos1_327);
+       ext_grs_edge_t *e_pos1_608_1017 = ext_grs_act_add_edge_to_keep(pattern, "pos1_608_1017", 0, n_Conv2992_716, n_Sub3034_444, 293, e_pos1_608);
+       ext_grs_edge_t *e_pos1_402_1018 = ext_grs_act_add_edge_to_keep(pattern, "pos1_402_1018", 0, n_Arg_0_507, n_VProj3252_691, 294, e_pos1_402);
+       ext_grs_edge_t *e_pos1_401_1019 = ext_grs_act_add_edge_to_keep(pattern, "pos1_401_1019", 0, n_VProj2643_462, n_Conv2644_512, 295, e_pos1_401);
+       ext_grs_edge_t *e_pos0_739_1020 = ext_grs_act_add_edge_to_keep(pattern, "pos0_739_1020", -1, n_Block2894_517, n_Sub2973_679, 296, e_pos0_739);
+       ext_grs_edge_t *e_pos1_323_1021 = ext_grs_act_add_edge_to_keep(pattern, "pos1_323_1021", 0, n_Arg_0_507, n_VProj3165_644, 297, e_pos1_323);
+       ext_grs_edge_t *e_pos0_738_1022 = ext_grs_act_add_edge_to_keep(pattern, "pos0_738_1022", -1, n_Block2720_559, n_Jmp2800_650, 298, e_pos0_738);
+       ext_grs_edge_t *e_pos2_609_1023 = ext_grs_act_add_edge_to_keep(pattern, "pos2_609_1023", 1, n_Conv3002_582, n_Sub3034_444, 299, e_pos2_609);
+       ext_grs_edge_t *e_pos0_348_1024 = ext_grs_act_add_edge_to_keep(pattern, "pos0_348_1024", -1, n_Block2546_634, n_Sub2625_616, 300, e_pos0_348);
+       ext_grs_edge_t *e_pos1_503_1025 = ext_grs_act_add_edge_to_keep(pattern, "pos1_503_1025", 0, n_VProj3687_675, n_Conv3688_475, 301, e_pos1_503);
+       ext_grs_edge_t *e_pos0_639_1026 = ext_grs_act_add_edge_to_keep(pattern, "pos0_639_1026", -1, n_Block3154_620, n_Sub3208_484, 302, e_pos0_639);
+       ext_grs_edge_t *e_pos1_502_1027 = ext_grs_act_add_edge_to_keep(pattern, "pos1_502_1027", 0, n_Arg_0_507, n_VProj3339_478, 303, e_pos1_502);
+       ext_grs_edge_t *e_pos1_703_1028 = ext_grs_act_add_edge_to_keep(pattern, "pos1_703_1028", 0, n_Arg_0_507, n_VProj2991_440, 304, e_pos1_703);
+       ext_grs_edge_t *e_pos2_605_1029 = ext_grs_act_add_edge_to_keep(pattern, "pos2_605_1029", 1, n_Conv2480_591, n_Cmp5646_563, 305, e_pos2_605);
+       ext_grs_edge_t *e_pos0_344_1030 = ext_grs_act_add_edge_to_keep(pattern, "pos0_344_1030", -1, n_Block3154_620, n_Jmp3209_501, 306, e_pos0_344);
+       ext_grs_edge_t *e_pos2_603_1031 = ext_grs_act_add_edge_to_keep(pattern, "pos2_603_1031", 1, n_Conv3698_483, n_Sub3730_477, 307, e_pos2_603);
+       ext_grs_edge_t *e_e681_1032 = ext_grs_act_add_edge_to_keep(pattern, "e681_1032", ext_grs_NO_EDGE_POS, n_Jmp2774_663, n_Block2751_520, 308, e_e681);
+       ext_grs_edge_t *e_pos1_509_1033 = ext_grs_act_add_edge_to_keep(pattern, "pos1_509_1033", 0, n_Conv3514_502, n_Cmp5658_589, 309, e_pos1_509);
+       ext_grs_edge_t *e_pos0_633_1034 = ext_grs_act_add_edge_to_keep(pattern, "pos0_633_1034", -1, n_Block2806_676, n_Sub2860_693, 310, e_pos0_633);
+       ext_grs_edge_t *e_e546_1035 = ext_grs_act_add_edge_to_keep(pattern, "e546_1035", ext_grs_NO_EDGE_POS, n_Proj2484_668, n_Block2459_572, 311, e_e546);
+       ext_grs_edge_t *e_e418_1036 = ext_grs_act_add_edge_to_keep(pattern, "e418_1036", ext_grs_NO_EDGE_POS, n_Proj2919_528, n_Block2894_517, 312, e_e418);
+       ext_grs_edge_t *e_e682_1037 = ext_grs_act_add_edge_to_keep(pattern, "e682_1037", ext_grs_NO_EDGE_POS, n_Jmp2800_650, n_Block2751_520, 313, e_e682);
+       ext_grs_edge_t *e_pos0_636_1038 = ext_grs_act_add_edge_to_keep(pattern, "pos0_636_1038", -1, n_Block3708_590, n_Add2892_554, 314, e_pos0_636);
+       ext_grs_edge_t *e_pos1_507_1039 = ext_grs_act_add_edge_to_keep(pattern, "pos1_507_1039", 0, n_Conv3698_483, n_Sub3756_445, 315, e_pos1_507);
+       ext_grs_edge_t *e_pos0_732_1040 = ext_grs_act_add_edge_to_keep(pattern, "pos0_732_1040", -1, n_Block3708_590, n_Add2544_476, 316, e_pos0_732);
+       ext_grs_edge_t *e_e689_1041 = ext_grs_act_add_edge_to_keep(pattern, "e689_1041", ext_grs_NO_EDGE_POS, n_Sub3147_493, n_Phi3185_570, 317, e_e689);
+       ext_grs_edge_t *e_pos1_405_1042 = ext_grs_act_add_edge_to_keep(pattern, "pos1_405_1042", 0, n_Cond3179_514, n_Proj3180_460, 318, e_pos1_405);
+       ext_grs_edge_t *e_e688_1043 = ext_grs_act_add_edge_to_keep(pattern, "e688_1043", ext_grs_NO_EDGE_POS, n_Sub3121_455, n_Phi3185_570, 319, e_e688);
+       ext_grs_edge_t *e_e541_1044 = ext_grs_act_add_edge_to_keep(pattern, "e541_1044", ext_grs_NO_EDGE_POS, n_Add3066_534, n_Add3153_632, 320, e_e541);
+       ext_grs_edge_t *e_e687_1045 = ext_grs_act_add_edge_to_keep(pattern, "e687_1045", ext_grs_NO_EDGE_POS, n_Block3099_472, n_Phi3185_570, 321, e_e687);
+       ext_grs_edge_t *e_e540_1046 = ext_grs_act_add_edge_to_keep(pattern, "e540_1046", ext_grs_NO_EDGE_POS, n_Phi3185_570, n_Add3153_632, 322, e_e540);
+       ext_grs_edge_t *e_pos0_735_1047 = ext_grs_act_add_edge_to_keep(pattern, "pos0_735_1047", -1, n_Block3590_547, n_Sub3669_485, 323, e_pos0_735);
+       ext_grs_edge_t *e_e686_1048 = ext_grs_act_add_edge_to_keep(pattern, "e686_1048", ext_grs_NO_EDGE_POS, n_Proj3615_694, n_Block3590_547, 324, e_e686);
+       ext_grs_edge_t *e_pos1_328_1049 = ext_grs_act_add_edge_to_keep(pattern, "pos1_328_1049", 0, n_Arg_0_507, n_VProj3600_510, 325, e_pos1_328);
+       ext_grs_edge_t *e_pos1_329_1050 = ext_grs_act_add_edge_to_keep(pattern, "pos1_329_1050", 0, n_Arg_0_507, n_VProj3078_654, 326, e_pos1_329);
+       ext_grs_edge_t *e_pos0_731_1051 = ext_grs_act_add_edge_to_keep(pattern, "pos0_731_1051", -1, n_Block2980_689, n_Jmp3035_479, 327, e_pos0_731);
+       ext_grs_edge_t *e_pos1_602_1052 = ext_grs_act_add_edge_to_keep(pattern, "pos1_602_1052", 0, n_Conv3688_475, n_Sub3730_477, 328, e_pos1_602);
+       ext_grs_edge_t *e_pos0_330_1053 = ext_grs_act_add_edge_to_keep(pattern, "pos0_330_1053", -1, n_Block3708_590, n_Add3675_669, 329, e_pos0_330);
+       ext_grs_edge_t *e_pos1_314_1054 = ext_grs_act_add_edge_to_keep(pattern, "pos1_314_1054", 0, n_Conv2992_716, n_Cmp5652_596, 330, e_pos1_314);
+       ext_grs_edge_t *e_pos0_749_1055 = ext_grs_act_add_edge_to_keep(pattern, "pos0_749_1055", -1, n_Block2404_719, n_Cond2483_560, 331, e_pos0_749);
+       ext_grs_edge_t *e_e408_1056 = ext_grs_act_add_edge_to_keep(pattern, "e408_1056", ext_grs_NO_EDGE_POS, n_Add3414_646, n_Add3501_658, 332, e_e408);
+       ext_grs_edge_t *e_e409_1057 = ext_grs_act_add_edge_to_keep(pattern, "e409_1057", ext_grs_NO_EDGE_POS, n_Proj3528_701, n_Block3503_708, 333, e_e409);
+       ext_grs_edge_t *e_pos0_649_1058 = ext_grs_act_add_edge_to_keep(pattern, "pos0_649_1058", -1, n_Block2546_634, n_Jmp2626_464, 334, e_pos0_649);
+       ext_grs_edge_t *e_pos0_648_1059 = ext_grs_act_add_edge_to_keep(pattern, "pos0_648_1059", -1, n_Block2376_552, n_Jmp2427_470, 335, e_pos0_648);
+       ext_grs_edge_t *e_pos0_335_1060 = ext_grs_act_add_edge_to_keep(pattern, "pos0_335_1060", -1, n_Block2720_559, n_Sub2799_488, 336, e_pos0_335);
+       ext_grs_edge_t *e_e690_1061 = ext_grs_act_add_edge_to_keep(pattern, "e690_1061", ext_grs_NO_EDGE_POS, n_Proj2746_712, n_Block2719_573, 337, e_e690);
+       ext_grs_edge_t *e_e400_1062 = ext_grs_act_add_edge_to_keep(pattern, "e400_1062", ext_grs_NO_EDGE_POS, n_Proj3094_537, n_Block3067_506, 338, e_e400);
+       ext_grs_edge_t *e_e692_1063 = ext_grs_act_add_edge_to_keep(pattern, "e692_1063", ext_grs_NO_EDGE_POS, n_Sub3469_667, n_Phi3533_607, 339, e_e692);
+       ext_grs_edge_t *e_e403_1064 = ext_grs_act_add_edge_to_keep(pattern, "e403_1064", ext_grs_NO_EDGE_POS, n_Jmp2687_677, n_Block2664_581, 340, e_e403);
+       ext_grs_edge_t *e_e691_1065 = ext_grs_act_add_edge_to_keep(pattern, "e691_1065", ext_grs_NO_EDGE_POS, n_Block3447_539, n_Phi3533_607, 341, e_e691);
+       ext_grs_edge_t *e_e555_1066 = ext_grs_act_add_edge_to_keep(pattern, "e555_1066", ext_grs_NO_EDGE_POS, n_Block2664_581, n_Phi2750_494, 342, e_e555);
+       ext_grs_edge_t *e_e693_1067 = ext_grs_act_add_edge_to_keep(pattern, "e693_1067", ext_grs_NO_EDGE_POS, n_Sub3495_648, n_Phi3533_607, 343, e_e693);
+       ext_grs_edge_t *e_e404_1068 = ext_grs_act_add_edge_to_keep(pattern, "e404_1068", ext_grs_NO_EDGE_POS, n_Jmp2713_544, n_Block2664_581, 344, e_e404);
+       ext_grs_edge_t *e_e557_1069 = ext_grs_act_add_edge_to_keep(pattern, "e557_1069", ext_grs_NO_EDGE_POS, n_Sub2712_631, n_Phi2750_494, 345, e_e557);
+       ext_grs_edge_t *e_e407_1070 = ext_grs_act_add_edge_to_keep(pattern, "e407_1070", ext_grs_NO_EDGE_POS, n_Phi3533_607, n_Add3501_658, 346, e_e407);
+       ext_grs_edge_t *e_e556_1071 = ext_grs_act_add_edge_to_keep(pattern, "e556_1071", ext_grs_NO_EDGE_POS, n_Sub2686_446, n_Phi2750_494, 347, e_e556);
+       ext_grs_edge_t *e_e698_1072 = ext_grs_act_add_edge_to_keep(pattern, "e698_1072", ext_grs_NO_EDGE_POS, n_Proj3006_664, n_Block2981_692, 348, e_e698);
+       ext_grs_edge_t *e_pos0_743_1073 = ext_grs_act_add_edge_to_keep(pattern, "pos0_743_1073", -1, n_Block3242_530, n_Sub3321_452, 349, e_pos0_743);
+       ext_grs_edge_t *e_e553_1074 = ext_grs_act_add_edge_to_keep(pattern, "e553_1074", ext_grs_NO_EDGE_POS, n_Jmp3322_466, n_Block3273_516, 350, e_e553);
+       ext_grs_edge_t *e_e699_1075 = ext_grs_act_add_edge_to_keep(pattern, "e699_1075", ext_grs_NO_EDGE_POS, n_Block3621_533, n_Phi3707_456, 351, e_e699);
+       ext_grs_edge_t *e_e552_1076 = ext_grs_act_add_edge_to_keep(pattern, "e552_1076", ext_grs_NO_EDGE_POS, n_Jmp3296_671, n_Block3273_516, 352, e_e552);
+       ext_grs_edge_t *e_pos1_319_1077 = ext_grs_act_add_edge_to_keep(pattern, "pos1_319_1077", 0, n_Cmp5646_563, n_Proj2482_660, 353, e_pos1_319);
+       ext_grs_edge_t *e_pos1_317_1078 = ext_grs_act_add_edge_to_keep(pattern, "pos1_317_1078", 0, n_Proj2830_487, n_Cond2831_513, 354, e_pos1_317);
+       ext_grs_edge_t *e_pos1_318_1079 = ext_grs_act_add_edge_to_keep(pattern, "pos1_318_1079", 0, n_VProj2740_524, n_Conv2741_656, 355, e_pos1_318);
+       ext_grs_edge_t *e_pos0_722_1080 = ext_grs_act_add_edge_to_keep(pattern, "pos0_722_1080", -1, n_Block2458_568, n_Jmp2513_697, 356, e_pos0_722);
+       ext_grs_edge_t *e_pos1_695_1081 = ext_grs_act_add_edge_to_keep(pattern, "pos1_695_1081", 0, n_Conv2470_579, n_Sub2512_566, 357, e_pos1_695);
+       ext_grs_edge_t *e_pos1_417_1082 = ext_grs_act_add_edge_to_keep(pattern, "pos1_417_1082", 0, n_Cond3440_459, n_Proj3442_458, 358, e_pos1_417);
+       ext_grs_edge_t *e_pos1_416_1083 = ext_grs_act_add_edge_to_keep(pattern, "pos1_416_1083", 0, n_Cmp5647_564, n_Proj2569_682, 359, e_pos1_416);
+       ext_grs_edge_t *e_pos1_697_1084 = ext_grs_act_add_edge_to_keep(pattern, "pos1_697_1084", 0, n_Arg_0_507, n_VProj2469_474, 360, e_pos1_697);
+       ext_grs_edge_t *e_pos0_723_1085 = ext_grs_act_add_edge_to_keep(pattern, "pos0_723_1085", -1, n_Block3068_508, n_Sub3147_493, 361, e_pos0_723);
+       ext_grs_edge_t *e_pos1_559_1086 = ext_grs_act_add_edge_to_keep(pattern, "pos1_559_1086", 0, n_Cond2657_577, n_Proj2658_622, 362, e_pos1_559);
+       ext_grs_edge_t *e_pos1_558_1087 = ext_grs_act_add_edge_to_keep(pattern, "pos1_558_1087", 0, n_Cond2657_577, n_Proj2659_623, 363, e_pos1_558);
+       ext_grs_edge_t *e_pos1_551_1088 = ext_grs_act_add_edge_to_keep(pattern, "pos1_551_1088", 0, n_Cmp5645_569, n_Proj2397_600, 364, e_pos1_551);
+       ext_grs_edge_t *e_pos1_554_1089 = ext_grs_act_add_edge_to_keep(pattern, "pos1_554_1089", 0, n_VProj3523_481, n_Conv3524_637, 365, e_pos1_554);
+       ext_grs_edge_t *e_pos1_410_1090 = ext_grs_act_add_edge_to_keep(pattern, "pos1_410_1090", 0, n_VProj2817_684, n_Conv2818_437, 366, e_pos1_410);
+       ext_grs_edge_t *e_pos1_550_1091 = ext_grs_act_add_edge_to_keep(pattern, "pos1_550_1091", 0, n_Arg_0_507, n_VProj2904_583, 367, e_pos1_550);
+       ext_grs_edge_t *e_pos1_411_1092 = ext_grs_act_add_edge_to_keep(pattern, "pos1_411_1092", 0, n_Conv3253_515, n_Cmp5655_593, 368, e_pos1_411);
+       ext_grs_edge_t *e_pos0_726_1093 = ext_grs_act_add_edge_to_keep(pattern, "pos0_726_1093", -1, n_Block3416_604, n_Sub3495_648, 369, e_pos0_726);
+       ext_grs_edge_t *e_pos1_413_1094 = ext_grs_act_add_edge_to_keep(pattern, "pos1_413_1094", 0, n_VProj2827_707, n_Conv2828_449, 370, e_pos1_413);
+       ext_grs_edge_t *e_pos1_414_1095 = ext_grs_act_add_edge_to_keep(pattern, "pos1_414_1095", 0, n_Arg_1_509, n_VProj2479_489, 371, e_pos1_414);
+       ext_grs_edge_t *e_pos1_415_1096 = ext_grs_act_add_edge_to_keep(pattern, "pos1_415_1096", 0, n_Cmp5654_594, n_Proj3178_430, 372, e_pos1_415);
+       ext_grs_edge_t *e_pos1_569_1097 = ext_grs_act_add_edge_to_keep(pattern, "pos1_569_1097", 0, n_Conv3688_475, n_Cmp5660_696, 373, e_pos1_569);
+       ext_grs_edge_t *e_pos1_567_1098 = ext_grs_act_add_edge_to_keep(pattern, "pos1_567_1098", 0, n_Cond2831_513, n_Proj2833_490, 374, e_pos1_567);
+       ext_grs_edge_t *e_pos1_422_1099 = ext_grs_act_add_edge_to_keep(pattern, "pos1_422_1099", 0, n_Cmp5659_586, n_Proj3613_690, 376, e_pos1_422);
+       ext_grs_edge_t *e_pos1_561_1100 = ext_grs_act_add_edge_to_keep(pattern, "pos1_561_1100", 0, n_Proj3352_645, n_Cond3353_640, 375, e_pos1_561);
+       ext_grs_edge_t *e_pos1_425_1101 = ext_grs_act_add_edge_to_keep(pattern, "pos1_425_1101", 0, n_Arg_0_507, n_VProj2643_462, 377, e_pos1_425);
+       ext_grs_edge_t *e_pos1_423_1102 = ext_grs_act_add_edge_to_keep(pattern, "pos1_423_1102", 0, n_Cmp5653_595, n_Proj3091_540, 378, e_pos1_423);
+       ext_grs_edge_t *e_pos1_438_1103 = ext_grs_act_add_edge_to_keep(pattern, "pos1_438_1103", 0, n_Cond3179_514, n_Proj3181_461, 379, e_pos1_438);
+       ext_grs_edge_t *e_pos0_601_1104 = ext_grs_act_add_edge_to_keep(pattern, "pos0_601_1104", -1, n_Block3676_492, n_Sub3730_477, 380, e_pos0_601);
+       ext_grs_edge_t *e_pos1_537_1105 = ext_grs_act_add_edge_to_keep(pattern, "pos1_537_1105", 0, n_Conv2828_449, n_Sub2886_434, 381, e_pos1_537);
+       ext_grs_edge_t *e_pos1_530_1106 = ext_grs_act_add_edge_to_keep(pattern, "pos1_530_1106", 0, n_Cmp5660_696, n_Proj3700_473, 382, e_pos1_530);
+       ext_grs_edge_t *e_pos1_531_1107 = ext_grs_act_add_edge_to_keep(pattern, "pos1_531_1107", 0, n_Cond3266_543, n_Proj3268_611, 383, e_pos1_531);
+       ext_grs_edge_t *e_pos1_533_1108 = ext_grs_act_add_edge_to_keep(pattern, "pos1_533_1108", 0, n_Conv3524_637, n_Sub3582_698, 384, e_pos1_533);
+       ext_grs_edge_t *e_pos0_607_1109 = ext_grs_act_add_edge_to_keep(pattern, "pos0_607_1109", -1, n_Block2980_689, n_Sub3034_444, 385, e_pos0_607);
+       ext_grs_edge_t *e_pos1_435_1110 = ext_grs_act_add_edge_to_keep(pattern, "pos1_435_1110", 0, n_Conv3340_580, n_Cmp5656_592, 386, e_pos1_435);
+       ext_grs_edge_t *e_pos1_437_1111 = ext_grs_act_add_edge_to_keep(pattern, "pos1_437_1111", 0, n_Arg_1_509, n_VProj2827_707, 387, e_pos1_437);
+       ext_grs_edge_t *e_pos0_707_1112 = ext_grs_act_add_edge_to_keep(pattern, "pos0_707_1112", -1, n_Block3708_590, n_Add2631_674, 388, e_pos0_707);
+       ext_grs_edge_t *e_pos1_432_1113 = ext_grs_act_add_edge_to_keep(pattern, "pos1_432_1113", 0, n_Arg_0_507, n_VProj2817_684, 389, e_pos1_432);
+       ext_grs_edge_t *e_pos1_548_1114 = ext_grs_act_add_edge_to_keep(pattern, "pos1_548_1114", 0, n_Conv3601_610, n_Cmp5659_586, 390, e_pos1_548);
+       ext_grs_edge_t *e_pos1_440_1115 = ext_grs_act_add_edge_to_keep(pattern, "pos1_440_1115", 0, n_Proj3526_704, n_Cond3527_441, 391, e_pos1_440);
+       ext_grs_edge_t *e_pos1_547_1116 = ext_grs_act_add_edge_to_keep(pattern, "pos1_547_1116", 0, n_Arg_0_507, n_VProj3687_675, 392, e_pos1_547);
+       ext_grs_edge_t *e_pos1_544_1117 = ext_grs_act_add_edge_to_keep(pattern, "pos1_544_1117", 0, n_Conv3176_683, n_Sub3234_431, 393, e_pos1_544);
+       ext_grs_edge_t *e_pos1_447_1118 = ext_grs_act_add_edge_to_keep(pattern, "pos1_447_1118", 0, n_Cond3614_613, n_Proj3616_695, 394, e_pos1_447);
+       ext_grs_edge_t *e_pos1_445_1119 = ext_grs_act_add_edge_to_keep(pattern, "pos1_445_1119", 0, n_Conv2557_624, n_Sub2599_651, 395, e_pos1_445);
+       ext_grs_edge_t *e_pos1_443_1120 = ext_grs_act_add_edge_to_keep(pattern, "pos1_443_1120", 0, n_Cond2570_505, n_Proj2572_662, 396, e_pos1_443);
+       ext_grs_edge_t *e_pos1_441_1121 = ext_grs_act_add_edge_to_keep(pattern, "pos1_441_1121", 0, n_VProj2385_438, n_Conv2386_599, 397, e_pos1_441);
+       ext_grs_edge_t *e_pos1_650_1122 = ext_grs_act_add_edge_to_keep(pattern, "pos1_650_1122", 0, n_Cond3440_459, n_Proj3441_457, 398, e_pos1_650);
+       ext_grs_edge_t *e_pos1_652_1123 = ext_grs_act_add_edge_to_keep(pattern, "pos1_652_1123", 0, n_Proj3439_443, n_Cond3440_459, 399, e_pos1_652);
+       ext_grs_edge_t *e_pos1_653_1124 = ext_grs_act_add_edge_to_keep(pattern, "pos1_653_1124", 0, n_VProj3349_463, n_Conv3350_557, 400, e_pos1_653);
+       ext_grs_edge_t *e_pos1_654_1125 = ext_grs_act_add_edge_to_keep(pattern, "pos1_654_1125", 0, n_Cond3701_714, n_Proj3703_468, 401, e_pos1_654);
+       ext_grs_edge_t *e_pos1_659_1126 = ext_grs_act_add_edge_to_keep(pattern, "pos1_659_1126", 0, n_Cond2831_513, n_Proj2832_486, 402, e_pos1_659);
+       ext_grs_edge_t *e_pos1_591_1127 = ext_grs_act_add_edge_to_keep(pattern, "pos1_591_1127", 0, n_Conv2654_525, n_Sub2712_631, 404, e_pos1_591);
+       ext_grs_edge_t *e_pos1_658_1128 = ext_grs_act_add_edge_to_keep(pattern, "pos1_658_1128", 0, n_Cond2918_588, n_Proj2920_535, 403, e_pos1_658);
+       ext_grs_edge_t *e_pos1_593_1129 = ext_grs_act_add_edge_to_keep(pattern, "pos1_593_1129", 0, n_Cond2483_560, n_Proj2484_668, 405, e_pos1_593);
+       ext_grs_edge_t *e_pos1_458_1130 = ext_grs_act_add_edge_to_keep(pattern, "pos1_458_1130", 0, n_VProj3339_478, n_Conv3340_580, 406, e_pos1_458);
+       ext_grs_edge_t *e_pos1_451_1131 = ext_grs_act_add_edge_to_keep(pattern, "pos1_451_1131", 0, n_Cond3527_441, n_Proj3528_701, 408, e_pos1_451);
+       ext_grs_edge_t *e_pos1_598_1132 = ext_grs_act_add_edge_to_keep(pattern, "pos1_598_1132", 0, n_Proj2917_531, n_Cond2918_588, 407, e_pos1_598);
+       ext_grs_edge_t *e_pos1_660_1133 = ext_grs_act_add_edge_to_keep(pattern, "pos1_660_1133", 0, n_Conv2644_512, n_Cmp5648_565, 409, e_pos1_660);
+       ext_grs_edge_t *e_pos1_668_1134 = ext_grs_act_add_edge_to_keep(pattern, "pos1_668_1134", 0, n_Arg_1_509, n_VProj3349_463, 410, e_pos1_668);
+       ext_grs_edge_t *e_pos1_665_1135 = ext_grs_act_add_edge_to_keep(pattern, "pos1_665_1135", 0, n_VProj2469_474, n_Conv2470_579, 411, e_pos1_665);
+       ext_grs_edge_t *e_pos1_466_1136 = ext_grs_act_add_edge_to_keep(pattern, "pos1_466_1136", 0, n_Conv3427_639, n_Cmp5657_587, 412, e_pos1_466);
+       ext_grs_edge_t *e_pos1_669_1137 = ext_grs_act_add_edge_to_keep(pattern, "pos1_669_1137", 0, n_Cmp5657_587, n_Proj3439_443, 413, e_pos1_669);
+       ext_grs_edge_t *e_pos1_469_1138 = ext_grs_act_add_edge_to_keep(pattern, "pos1_469_1138", 0, n_Conv2386_599, n_Sub2426_584, 414, e_pos1_469);
+       ext_grs_edge_t *e_pos1_670_1139 = ext_grs_act_add_edge_to_keep(pattern, "pos1_670_1139", 0, n_VProj2991_440, n_Conv2992_716, 415, e_pos1_670);
+       ext_grs_edge_t *e_pos1_679_1140 = ext_grs_act_add_edge_to_keep(pattern, "pos1_679_1140", 0, n_Proj3004_657, n_Cond3005_659, 416, e_pos1_679);
+       ext_grs_edge_t *e_pos1_673_1141 = ext_grs_act_add_edge_to_keep(pattern, "pos1_673_1141", 0, n_Conv2644_512, n_Sub2686_446, 417, e_pos1_673);
+       ext_grs_edge_t *e_pos0_292_1142 = ext_grs_act_add_edge_to_keep(pattern, "pos0_292_1142", -1, n_Vector_op_Block_706, n_Proj2399_601, 418, e_pos0_292);
+       ext_grs_edge_t *e_pos1_475_1143 = ext_grs_act_add_edge_to_keep(pattern, "pos1_475_1143", 0, n_Cond2918_588, n_Proj2919_528, 419, e_pos1_475);
+       ext_grs_edge_t *e_pos1_474_1144 = ext_grs_act_add_edge_to_keep(pattern, "pos1_474_1144", 0, n_VProj2566_480, n_Conv2567_647, 420, e_pos1_474);
+       ext_grs_edge_t *e_pos1_476_1145 = ext_grs_act_add_edge_to_keep(pattern, "pos1_476_1145", 0, n_Arg_1_509, n_VProj3436_546, 421, e_pos1_476);
+       ext_grs_edge_t *e_pos1_473_1146 = ext_grs_act_add_edge_to_keep(pattern, "pos1_473_1146", 0, n_VProj3175_652, n_Conv3176_683, 422, e_pos1_473);
+       ext_grs_edge_t *e_pos1_472_1147 = ext_grs_act_add_edge_to_keep(pattern, "pos1_472_1147", 0, n_Proj3265_608, n_Cond3266_543, 424, e_pos1_472);
+       ext_grs_edge_t *e_pos1_575_1148 = ext_grs_act_add_edge_to_keep(pattern, "pos1_575_1148", 0, n_Conv2386_599, n_Cmp5645_569, 423, e_pos1_575);
+       ext_grs_edge_t *e_pos1_578_1149 = ext_grs_act_add_edge_to_keep(pattern, "pos1_578_1149", 0, n_VProj3262_717, n_Conv3263_532, 425, e_pos1_578);
+       ext_grs_edge_t *e_pos1_579_1150 = ext_grs_act_add_edge_to_keep(pattern, "pos1_579_1150", 0, n_Cond3701_714, n_Proj3702_469, 426, e_pos1_579);
+       ext_grs_edge_t *e_pos1_680_1151 = ext_grs_act_add_edge_to_keep(pattern, "pos1_680_1151", 0, n_VProj2914_688, n_Conv2915_439, 427, e_pos1_680);
+       ext_grs_edge_t *e_pos1_683_1152 = ext_grs_act_add_edge_to_keep(pattern, "pos1_683_1152", 0, n_Cond3266_543, n_Proj3267_609, 428, e_pos1_683);
+       ext_grs_edge_t *e_pos1_684_1153 = ext_grs_act_add_edge_to_keep(pattern, "pos1_684_1153", 0, n_Conv2731_678, n_Cmp5649_567, 429, e_pos1_684);
+       ext_grs_edge_t *e_pos1_583_1154 = ext_grs_act_add_edge_to_keep(pattern, "pos1_583_1154", 0, n_VProj2653_447, n_Conv2654_525, 430, e_pos1_583);
+       ext_grs_edge_t *e_pos1_487_1155 = ext_grs_act_add_edge_to_keep(pattern, "pos1_487_1155", 0, n_VProj3088_672, n_Conv3089_454, 432, e_pos1_487);
+       ext_grs_edge_t *e_pos1_582_1156 = ext_grs_act_add_edge_to_keep(pattern, "pos1_582_1156", 0, n_Proj2743_713, n_Cond2744_642, 431, e_pos1_582);
+       ext_grs_edge_t *e_pos1_486_1157 = ext_grs_act_add_edge_to_keep(pattern, "pos1_486_1157", 0, n_VProj3610_471, n_Conv3611_636, 433, e_pos1_486);
+       ext_grs_edge_t *e_pos1_485_1158 = ext_grs_act_add_edge_to_keep(pattern, "pos1_485_1158", 0, n_Proj3700_473, n_Cond3701_714, 435, e_pos1_485);
+       ext_grs_edge_t *e_pos1_580_1159 = ext_grs_act_add_edge_to_keep(pattern, "pos1_580_1159", 0, n_Arg_1_509, n_VProj3523_481, 434, e_pos1_580);
+       ext_grs_edge_t *e_pos1_587_1160 = ext_grs_act_add_edge_to_keep(pattern, "pos1_587_1160", 0, n_VProj3697_626, n_Conv3698_483, 436, e_pos1_587);
+       ext_grs_edge_t *e_pos1_586_1161 = ext_grs_act_add_edge_to_keep(pattern, "pos1_586_1161", 0, n_Cond3092_576, n_Proj3093_536, 437, e_pos1_586);
+       ext_grs_edge_t *e_pos1_482_1162 = ext_grs_act_add_edge_to_keep(pattern, "pos1_482_1162", 0, n_Proj2656_621, n_Cond2657_577, 438, e_pos1_482);
+       ext_grs_edge_t *e_pos1_480_1163 = ext_grs_act_add_edge_to_keep(pattern, "pos1_480_1163", 0, n_Cmp5658_589, n_Proj3526_704, 439, e_pos1_480);
+       ext_grs_edge_t *e_pos1_588_1164 = ext_grs_act_add_edge_to_keep(pattern, "pos1_588_1164", 0, n_Cmp5656_592, n_Proj3352_645, 440, e_pos1_588);
+       ext_grs_edge_t *e_e290_1165 = ext_grs_act_add_edge_to_keep(pattern, "e290_1165", ext_grs_NO_EDGE_POS, n_Proj2485_666, n_Block2458_568, 441, e_e290);
+       ext_grs_edge_t *e_e382_1166 = ext_grs_act_add_edge_to_keep(pattern, "e382_1166", ext_grs_NO_EDGE_POS, n_Proj3181_461, n_Block3154_620, 442, e_e382);
+       ext_grs_edge_t *e_pos2_696_1167 = ext_grs_act_add_edge_to_keep(pattern, "pos2_696_1167", 1, n_Conv2480_591, n_Sub2512_566, 443, e_pos2_696);
+       ext_grs_edge_t *e_pos2_508_1168 = ext_grs_act_add_edge_to_keep(pattern, "pos2_508_1168", 1, n_Conv3688_475, n_Sub3756_445, 444, e_pos2_508);
+       ext_grs_edge_t *e_e395_1169 = ext_grs_act_add_edge_to_keep(pattern, "e395_1169", ext_grs_NO_EDGE_POS, n_Proj2572_662, n_Block2545_633, 445, e_e395);
+       ext_grs_edge_t *e_e399_1170 = ext_grs_act_add_edge_to_keep(pattern, "e399_1170", ext_grs_NO_EDGE_POS, n_Proj3616_695, n_Block3589_541, 446, e_e399);
+       ext_grs_edge_t *e_e299_1171 = ext_grs_act_add_edge_to_keep(pattern, "e299_1171", ext_grs_NO_EDGE_POS, n_Sub2773_522, n_Phi2837_527, 447, e_e299);
+       ext_grs_edge_t *e_e298_1172 = ext_grs_act_add_edge_to_keep(pattern, "e298_1172", ext_grs_NO_EDGE_POS, n_Block2751_520, n_Phi2837_527, 448, e_e298);
+       ext_grs_edge_t *e_e295_1173 = ext_grs_act_add_edge_to_keep(pattern, "e295_1173", ext_grs_NO_EDGE_POS, n_Proj3529_700, n_Block3502_709, 449, e_e295);
+       ext_grs_edge_t *e_e296_1174 = ext_grs_act_add_edge_to_keep(pattern, "e296_1174", ext_grs_NO_EDGE_POS, n_Proj3007_665, n_Block2980_689, 450, e_e296);
+       ext_grs_edge_t *e_pos2_516_1175 = ext_grs_act_add_edge_to_keep(pattern, "pos2_516_1175", 1, n_Conv2992_716, n_Sub3060_699, 451, e_pos2_516);
+       ext_grs_edge_t *e_pos2_315_1176 = ext_grs_act_add_edge_to_keep(pattern, "pos2_315_1176", 1, n_Conv3002_582, n_Cmp5652_596, 452, e_pos2_315);
+       ext_grs_edge_t *e_pos2_510_1177 = ext_grs_act_add_edge_to_keep(pattern, "pos2_510_1177", 1, n_Conv3524_637, n_Cmp5658_589, 453, e_pos2_510);
+       ext_grs_edge_t *e_pos2_521_1178 = ext_grs_act_add_edge_to_keep(pattern, "pos2_521_1178", 1, n_Conv3340_580, n_Sub3408_653, 454, e_pos2_521);
+       ext_grs_edge_t *e_pos2_538_1179 = ext_grs_act_add_edge_to_keep(pattern, "pos2_538_1179", 1, n_Conv2818_437, n_Sub2886_434, 455, e_pos2_538);
+       ext_grs_edge_t *e_pos2_436_1180 = ext_grs_act_add_edge_to_keep(pattern, "pos2_436_1180", 1, n_Conv3350_557, n_Cmp5656_592, 456, e_pos2_436);
+       ext_grs_edge_t *e_pos2_534_1181 = ext_grs_act_add_edge_to_keep(pattern, "pos2_534_1181", 1, n_Conv3514_502, n_Sub3582_698, 457, e_pos2_534);
+       ext_grs_edge_t *e_pos2_549_1182 = ext_grs_act_add_edge_to_keep(pattern, "pos2_549_1182", 1, n_Conv3611_636, n_Cmp5659_586, 458, e_pos2_549);
+       ext_grs_edge_t *e_pos2_446_1183 = ext_grs_act_add_edge_to_keep(pattern, "pos2_446_1183", 1, n_Conv2567_647, n_Sub2599_651, 459, e_pos2_446);
+       ext_grs_edge_t *e_pos2_545_1184 = ext_grs_act_add_edge_to_keep(pattern, "pos2_545_1184", 1, n_Conv3166_705, n_Sub3234_431, 460, e_pos2_545);
+       ext_grs_edge_t *e_pos2_412_1185 = ext_grs_act_add_edge_to_keep(pattern, "pos2_412_1185", 1, n_Conv3263_532, n_Cmp5655_593, 461, e_pos2_412);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_44235);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_44238);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* psadbw_variant0 */
+
+
+/* functions for evaluation of conditions of action vload_16b_variant0 */
+static int grs_cond_func_32999(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[54/* Const944 */])) == 14;
+}
+static int grs_cond_func_33002(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[9/* Const727 */])) == 0;
+}
+static int grs_cond_func_33005(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[56/* MultipleAdd5701 */]) == 2;
+}
+static int grs_cond_func_33008(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[59/* Vector_Result0_Proj741 */]) == 3;
+}
+static int grs_cond_func_33011(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[61/* Proj815 */]) == 0;
+}
+static int grs_cond_func_33014(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[42/* Vector_Result11_Proj906 */]) == 3;
+}
+static int grs_cond_func_33017(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[8/* Proj740 */]) == 0;
+}
+static int grs_cond_func_33020(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[12/* MultipleAdd5717 */]) == 2;
+}
+static int grs_cond_func_33023(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[33/* MultipleAdd5693 */]) == 2;
+}
+static int grs_cond_func_33026(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[1/* Const959 */])) == 15;
+}
+static int grs_cond_func_33029(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[7/* Proj935 */]) == 0;
+}
+static int grs_cond_func_33032(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[37/* Vector_Result8_Proj861 */]) == 3;
+}
+static int grs_cond_func_33035(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[58/* MultipleAdd5703 */]) == 2;
+}
+static int grs_cond_func_33038(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[22/* Const824 */])) == 6;
+}
+static int grs_cond_func_33041(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[75/* Proj830 */]) == 0;
+}
+static int grs_cond_func_33044(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[62/* Proj755 */]) == 0;
+}
+static int grs_cond_func_33047(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[73/* Vector_Result2_Proj771 */]) == 3;
+}
+static int grs_cond_func_33050(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[10/* MultipleAdd5719 */]) == 2;
+}
+static int grs_cond_func_33053(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[30/* Vector_Result13_Proj936 */]) == 3;
+}
+static int grs_cond_func_33056(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[43/* MultipleAdd5695 */]) == 2;
+}
+static int grs_cond_func_33059(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[44/* Proj950 */]) == 0;
+}
+static int grs_cond_func_33062(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[27/* Const899 */])) == 11;
+}
+static int grs_cond_func_33065(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[57/* MultipleAdd5705 */]) == 2;
+}
+static int grs_cond_func_33068(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[45/* Proj845 */]) == 0;
+}
+static int grs_cond_func_33071(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[76/* Proj770 */]) == 0;
+}
+static int grs_cond_func_33074(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[20/* Const854 */])) == 8;
+}
+static int grs_cond_func_33077(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[38/* MultipleAdd5697 */]) == 2;
+}
+static int grs_cond_func_33080(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[5/* MultipleAdd5723 */]) == 2;
+}
+static int grs_cond_func_33083(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[60/* Vector_Result4_Proj801 */]) == 3;
+}
+static int grs_cond_func_33086(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[77/* Proj965 */]) == 0;
+}
+static int grs_cond_func_33089(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[46/* Vector_Result5_Proj816 */]) == 3;
+}
+static int grs_cond_func_33092(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[0/* Const764 */])) == 2;
+}
+static int grs_cond_func_33095(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[39/* MultipleAdd5707 */]) == 2;
+}
+static int grs_cond_func_33098(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[14/* Const929 */])) == 13;
+}
+static int grs_cond_func_33101(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[55/* Proj860 */]) == 0;
+}
+static int grs_cond_func_33104(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[35/* Proj785 */]) == 0;
+}
+static int grs_cond_func_33107(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[71/* Vector_Result10_Proj891 */]) == 3;
+}
+static int grs_cond_func_33110(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[50/* MultipleAdd5699 */]) == 2;
+}
+static int grs_cond_func_33113(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[41/* MultipleAdd5709 */]) == 2;
+}
+static int grs_cond_func_33116(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[16/* Vector_Result7_Proj846 */]) == 3;
+}
+static int grs_cond_func_33119(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[51/* Const794 */])) == 4;
+}
+static int grs_cond_func_33122(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj875 */]) == 0;
+}
+static int grs_cond_func_33125(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[29/* Proj800 */]) == 0;
+}
+static int grs_cond_func_33128(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[66/* Const809 */])) == 5;
+}
+static int grs_cond_func_33131(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[3/* Vector_Result1_Proj756 */]) == 3;
+}
+static int grs_cond_func_33134(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[4/* Vector_Result12_Proj921 */]) == 3;
+}
+static int grs_cond_func_33137(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[74/* Const731 */])) == 10;
+}
+static int grs_cond_func_33140(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[31/* MultipleAdd5711 */]) == 2;
+}
+static int grs_cond_func_33143(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[23/* Proj890 */]) == 0;
+}
+static int grs_cond_func_33146(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[25/* Vector_Result9_Proj876 */]) == 3;
+}
+static int grs_cond_func_33149(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[81/* Const839 */])) == 7;
+}
+static int grs_cond_func_33152(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[64/* Vector_Result3_Proj786 */]) == 3;
+}
+static int grs_cond_func_33155(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[24/* MultipleAdd5713 */]) == 2;
+}
+static int grs_cond_func_33158(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[72/* Const735 */])) == 1;
+}
+static int grs_cond_func_33161(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[52/* Const914 */])) == 12;
+}
+static int grs_cond_func_33164(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[49/* Proj905 */]) == 0;
+}
+static int grs_cond_func_33167(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[6/* Vector_Result14_Proj951 */]) == 3;
+}
+static int grs_cond_func_33170(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[79/* Vector_Result15_Proj966 */]) == 3;
+}
+static int grs_cond_func_33173(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[18/* Const869 */])) == 9;
+}
+static int grs_cond_func_33176(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[26/* MultipleAdd5715 */]) == 2;
+}
+static int grs_cond_func_33179(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[34/* MultipleAdd5691 */]) == 2;
+}
+static int grs_cond_func_33182(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[40/* Vector_Result6_Proj831 */]) == 3;
+}
+static int grs_cond_func_33185(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[80/* Proj920 */]) == 0;
+}
+static int grs_cond_func_33188(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[67/* Const779 */])) == 3;
+}
+
+static void *grs_eval_out_func_33557(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[94/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_33560(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[93/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_33563(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[97/* VProj82 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_33566(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[90/* VProj84 */], 11);
+  return(NULL);
+}
+static void *grs_eval_out_func_33569(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[88/* VProj86 */], 8);
+  return(NULL);
+}
+static void *grs_eval_out_func_33572(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[100/* VProj88 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_33575(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[87/* VProj90 */], 13);
+  return(NULL);
+}
+static void *grs_eval_out_func_33578(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[96/* VProj92 */], 4);
+  return(NULL);
+}
+static void *grs_eval_out_func_33581(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[91/* VProj94 */], 5);
+  return(NULL);
+}
+static void *grs_eval_out_func_33584(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[99/* VProj96 */], 10);
+  return(NULL);
+}
+static void *grs_eval_out_func_33587(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[85/* VProj98 */], 7);
+  return(NULL);
+}
+static void *grs_eval_out_func_33590(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[82/* VProj100 */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_33593(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[83/* VProj102 */], 12);
+  return(NULL);
+}
+static void *grs_eval_out_func_33596(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[86/* VProj104 */], 9);
+  return(NULL);
+}
+static void *grs_eval_out_func_33599(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[98/* VProj106 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_33602(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[84/* VProj108 */], 14);
+  return(NULL);
+}
+static void *grs_eval_out_func_33605(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[101/* VProj110 */], 15);
+  return(NULL);
+}
+static void *grs_eval_out_func_33608(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[89/* VProj112 */], 6);
+  return(NULL);
+}
+/* functions for building the pattern of action vload_16b_variant0 */
+static _inline ext_grs_action_t *grs_action_vload_16b_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vload_16b_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Const764 = ext_grs_act_add_node(pattern, "Const764", grs_op_Const, mode_Is, 0);
+    ext_grs_node_t *n_Const959 = ext_grs_act_add_node(pattern, "Const959", grs_op_Const, mode_Is, 1);
+    ext_grs_node_t *n_Load874 = ext_grs_act_add_node(pattern, "Load874", grs_op_Load, mode_T, 2);
+    ext_grs_node_t *n_Vector_Result1_Proj756 = ext_grs_act_add_node(pattern, "Vector_Result1_Proj756", grs_op_Proj, mode_Bu, 3);
+    ext_grs_node_t *n_Vector_Result12_Proj921 = ext_grs_act_add_node(pattern, "Vector_Result12_Proj921", grs_op_Proj, mode_Bu, 4);
+    ext_grs_node_t *n_MultipleAdd5723 = ext_grs_act_add_node(pattern, "MultipleAdd5723", grs_op_MultipleAdd, mode_P, 5);
+    ext_grs_node_t *n_Vector_Result14_Proj951 = ext_grs_act_add_node(pattern, "Vector_Result14_Proj951", grs_op_Proj, mode_Bu, 6);
+    ext_grs_node_t *n_Proj935 = ext_grs_act_add_node(pattern, "Proj935", grs_op_Proj, mode_M, 7);
+    ext_grs_node_t *n_Proj740 = ext_grs_act_add_node(pattern, "Proj740", grs_op_Proj, mode_M, 8);
+    ext_grs_node_t *n_Const727 = ext_grs_act_add_node(pattern, "Const727", grs_op_Const, mode_Is, 9);
+    ext_grs_node_t *n_MultipleAdd5719 = ext_grs_act_add_node(pattern, "MultipleAdd5719", grs_op_MultipleAdd, mode_P, 10);
+    ext_grs_node_t *n_Load934 = ext_grs_act_add_node(pattern, "Load934", grs_op_Load, mode_T, 11);
+    ext_grs_node_t *n_MultipleAdd5717 = ext_grs_act_add_node(pattern, "MultipleAdd5717", grs_op_MultipleAdd, mode_P, 12);
+    ext_grs_node_t *n_Load739 = ext_grs_act_add_node(pattern, "Load739", grs_op_Load, mode_T, 13);
+    ext_grs_node_t *n_Const929 = ext_grs_act_add_node(pattern, "Const929", grs_op_Const, mode_Is, 14);
+    ext_grs_node_t *n_Load829 = ext_grs_act_add_node(pattern, "Load829", grs_op_Load, mode_T, 15);
+    ext_grs_node_t *n_Vector_Result7_Proj846 = ext_grs_act_add_node(pattern, "Vector_Result7_Proj846", grs_op_Proj, mode_Bu, 16);
+    ext_grs_node_t *n_Proj875 = ext_grs_act_add_node(pattern, "Proj875", grs_op_Proj, mode_M, 17);
+    ext_grs_node_t *n_Const869 = ext_grs_act_add_node(pattern, "Const869", grs_op_Const, mode_Is, 18);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 19);
+    ext_grs_node_t *n_Const854 = ext_grs_act_add_node(pattern, "Const854", grs_op_Const, mode_Is, 20);
+    ext_grs_node_t *n_Load844 = ext_grs_act_add_node(pattern, "Load844", grs_op_Load, mode_T, 21);
+    ext_grs_node_t *n_Const824 = ext_grs_act_add_node(pattern, "Const824", grs_op_Const, mode_Is, 22);
+    ext_grs_node_t *n_Proj890 = ext_grs_act_add_node(pattern, "Proj890", grs_op_Proj, mode_M, 23);
+    ext_grs_node_t *n_MultipleAdd5713 = ext_grs_act_add_node(pattern, "MultipleAdd5713", grs_op_MultipleAdd, mode_P, 24);
+    ext_grs_node_t *n_Vector_Result9_Proj876 = ext_grs_act_add_node(pattern, "Vector_Result9_Proj876", grs_op_Proj, mode_Bu, 25);
+    ext_grs_node_t *n_MultipleAdd5715 = ext_grs_act_add_node(pattern, "MultipleAdd5715", grs_op_MultipleAdd, mode_P, 26);
+    ext_grs_node_t *n_Const899 = ext_grs_act_add_node(pattern, "Const899", grs_op_Const, mode_Is, 27);
+    ext_grs_node_t *n_Load889 = ext_grs_act_add_node(pattern, "Load889", grs_op_Load, mode_T, 28);
+    ext_grs_node_t *n_Proj800 = ext_grs_act_add_node(pattern, "Proj800", grs_op_Proj, mode_M, 29);
+    ext_grs_node_t *n_Vector_Result13_Proj936 = ext_grs_act_add_node(pattern, "Vector_Result13_Proj936", grs_op_Proj, mode_Bu, 30);
+    ext_grs_node_t *n_MultipleAdd5711 = ext_grs_act_add_node(pattern, "MultipleAdd5711", grs_op_MultipleAdd, mode_P, 31);
+    ext_grs_node_t *n_Load949 = ext_grs_act_add_node(pattern, "Load949", grs_op_Load, mode_T, 32);
+    ext_grs_node_t *n_MultipleAdd5693 = ext_grs_act_add_node(pattern, "MultipleAdd5693", grs_op_MultipleAdd, mode_P, 33);
+    ext_grs_node_t *n_MultipleAdd5691 = ext_grs_act_add_node(pattern, "MultipleAdd5691", grs_op_MultipleAdd, mode_P, 34);
+    ext_grs_node_t *n_Proj785 = ext_grs_act_add_node(pattern, "Proj785", grs_op_Proj, mode_M, 35);
+    ext_grs_node_t *n_Load799 = ext_grs_act_add_node(pattern, "Load799", grs_op_Load, mode_T, 36);
+    ext_grs_node_t *n_Vector_Result8_Proj861 = ext_grs_act_add_node(pattern, "Vector_Result8_Proj861", grs_op_Proj, mode_Bu, 37);
+    ext_grs_node_t *n_MultipleAdd5697 = ext_grs_act_add_node(pattern, "MultipleAdd5697", grs_op_MultipleAdd, mode_P, 38);
+    ext_grs_node_t *n_MultipleAdd5707 = ext_grs_act_add_node(pattern, "MultipleAdd5707", grs_op_MultipleAdd, mode_P, 39);
+    ext_grs_node_t *n_Vector_Result6_Proj831 = ext_grs_act_add_node(pattern, "Vector_Result6_Proj831", grs_op_Proj, mode_Bu, 40);
+    ext_grs_node_t *n_MultipleAdd5709 = ext_grs_act_add_node(pattern, "MultipleAdd5709", grs_op_MultipleAdd, mode_P, 41);
+    ext_grs_node_t *n_Vector_Result11_Proj906 = ext_grs_act_add_node(pattern, "Vector_Result11_Proj906", grs_op_Proj, mode_Bu, 42);
+    ext_grs_node_t *n_MultipleAdd5695 = ext_grs_act_add_node(pattern, "MultipleAdd5695", grs_op_MultipleAdd, mode_P, 43);
+    ext_grs_node_t *n_Proj950 = ext_grs_act_add_node(pattern, "Proj950", grs_op_Proj, mode_M, 44);
+    ext_grs_node_t *n_Proj845 = ext_grs_act_add_node(pattern, "Proj845", grs_op_Proj, mode_M, 45);
+    ext_grs_node_t *n_Vector_Result5_Proj816 = ext_grs_act_add_node(pattern, "Vector_Result5_Proj816", grs_op_Proj, mode_Bu, 46);
+    ext_grs_node_t *n_Load904 = ext_grs_act_add_node(pattern, "Load904", grs_op_Load, mode_T, 47);
+    ext_grs_node_t *n_Load784 = ext_grs_act_add_node(pattern, "Load784", grs_op_Load, mode_T, 48);
+    ext_grs_node_t *n_Proj905 = ext_grs_act_add_node(pattern, "Proj905", grs_op_Proj, mode_M, 49);
+    ext_grs_node_t *n_MultipleAdd5699 = ext_grs_act_add_node(pattern, "MultipleAdd5699", grs_op_MultipleAdd, mode_P, 50);
+    ext_grs_node_t *n_Const794 = ext_grs_act_add_node(pattern, "Const794", grs_op_Const, mode_Is, 51);
+    ext_grs_node_t *n_Const914 = ext_grs_act_add_node(pattern, "Const914", grs_op_Const, mode_Is, 52);
+    ext_grs_node_t *n_Load859 = ext_grs_act_add_node(pattern, "Load859", grs_op_Load, mode_T, 53);
+    ext_grs_node_t *n_Const944 = ext_grs_act_add_node(pattern, "Const944", grs_op_Const, mode_Is, 54);
+    ext_grs_node_t *n_Proj860 = ext_grs_act_add_node(pattern, "Proj860", grs_op_Proj, mode_M, 55);
+    ext_grs_node_t *n_MultipleAdd5701 = ext_grs_act_add_node(pattern, "MultipleAdd5701", grs_op_MultipleAdd, mode_P, 56);
+    ext_grs_node_t *n_MultipleAdd5705 = ext_grs_act_add_node(pattern, "MultipleAdd5705", grs_op_MultipleAdd, mode_P, 57);
+    ext_grs_node_t *n_MultipleAdd5703 = ext_grs_act_add_node(pattern, "MultipleAdd5703", grs_op_MultipleAdd, mode_P, 58);
+    ext_grs_node_t *n_Vector_Result0_Proj741 = ext_grs_act_add_node(pattern, "Vector_Result0_Proj741", grs_op_Proj, mode_Bu, 59);
+    ext_grs_node_t *n_Vector_Result4_Proj801 = ext_grs_act_add_node(pattern, "Vector_Result4_Proj801", grs_op_Proj, mode_Bu, 60);
+    ext_grs_node_t *n_Proj815 = ext_grs_act_add_node(pattern, "Proj815", grs_op_Proj, mode_M, 61);
+    ext_grs_node_t *n_Proj755 = ext_grs_act_add_node(pattern, "Proj755", grs_op_Proj, mode_M, 62);
+    ext_grs_node_t *n_Load814 = ext_grs_act_add_node(pattern, "Load814", grs_op_Load, mode_T, 63);
+    ext_grs_node_t *n_Vector_Result3_Proj786 = ext_grs_act_add_node(pattern, "Vector_Result3_Proj786", grs_op_Proj, mode_Bu, 64);
+    ext_grs_node_t *n_Load754 = ext_grs_act_add_node(pattern, "Load754", grs_op_Load, mode_T, 65);
+    ext_grs_node_t *n_Const809 = ext_grs_act_add_node(pattern, "Const809", grs_op_Const, mode_Is, 66);
+    ext_grs_node_t *n_Const779 = ext_grs_act_add_node(pattern, "Const779", grs_op_Const, mode_Is, 67);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 68);
+    ext_grs_node_t *n_Load964 = ext_grs_act_add_node(pattern, "Load964", grs_op_Load, mode_T, 69);
+    ext_grs_node_t *n_Load919 = ext_grs_act_add_node(pattern, "Load919", grs_op_Load, mode_T, 70);
+    ext_grs_node_t *n_Vector_Result10_Proj891 = ext_grs_act_add_node(pattern, "Vector_Result10_Proj891", grs_op_Proj, mode_Bu, 71);
+    ext_grs_node_t *n_Const735 = ext_grs_act_add_node(pattern, "Const735", grs_op_Const, mode_Is, 72);
+    ext_grs_node_t *n_Vector_Result2_Proj771 = ext_grs_act_add_node(pattern, "Vector_Result2_Proj771", grs_op_Proj, mode_Bu, 73);
+    ext_grs_node_t *n_Const731 = ext_grs_act_add_node(pattern, "Const731", grs_op_Const, mode_Is, 74);
+    ext_grs_node_t *n_Proj830 = ext_grs_act_add_node(pattern, "Proj830", grs_op_Proj, mode_M, 75);
+    ext_grs_node_t *n_Proj770 = ext_grs_act_add_node(pattern, "Proj770", grs_op_Proj, mode_M, 76);
+    ext_grs_node_t *n_Proj965 = ext_grs_act_add_node(pattern, "Proj965", grs_op_Proj, mode_M, 77);
+    ext_grs_node_t *n_Load769 = ext_grs_act_add_node(pattern, "Load769", grs_op_Load, mode_T, 78);
+    ext_grs_node_t *n_Vector_Result15_Proj966 = ext_grs_act_add_node(pattern, "Vector_Result15_Proj966", grs_op_Proj, mode_Bu, 79);
+    ext_grs_node_t *n_Proj920 = ext_grs_act_add_node(pattern, "Proj920", grs_op_Proj, mode_M, 80);
+    ext_grs_node_t *n_Const839 = ext_grs_act_add_node(pattern, "Const839", grs_op_Const, mode_Is, 81);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_146 = ext_grs_act_add_edge(pattern, "pos1_146", 0, n_Load784, n_Vector_Result3_Proj786, 0);
+    ext_grs_edge_t *e_pos1_145 = ext_grs_act_add_edge(pattern, "pos1_145", 0, n_Load874, n_Vector_Result9_Proj876, 1);
+    ext_grs_edge_t *e_pos1_144 = ext_grs_act_add_edge(pattern, "pos1_144", 0, n_Load889, n_Proj890, 2);
+    ext_grs_edge_t *e_e130 = ext_grs_act_add_edge(pattern, "e130", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5699, 3);
+    ext_grs_edge_t *e_e133 = ext_grs_act_add_edge(pattern, "e133", ext_grs_NO_EDGE_POS, n_Const824, n_MultipleAdd5709, 4);
+    ext_grs_edge_t *e_e134 = ext_grs_act_add_edge(pattern, "e134", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5709, 5);
+    ext_grs_edge_t *e_e83 = ext_grs_act_add_edge(pattern, "e83", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5701, 6);
+    ext_grs_edge_t *e_e82 = ext_grs_act_add_edge(pattern, "e82", ext_grs_NO_EDGE_POS, n_Const731, n_MultipleAdd5701, 7);
+    ext_grs_edge_t *e_pos1_136 = ext_grs_act_add_edge(pattern, "pos1_136", 0, n_Load799, n_Proj800, 8);
+    ext_grs_edge_t *e_pos2_102 = ext_grs_act_add_edge(pattern, "pos2_102", 1, n_MultipleAdd5705, n_Load859, 9);
+    ext_grs_edge_t *e_pos1_135 = ext_grs_act_add_edge(pattern, "pos1_135", 0, n_Load874, n_Proj875, 10);
+    ext_grs_edge_t *e_pos1_137 = ext_grs_act_add_edge(pattern, "pos1_137", 0, n_Load754, n_Vector_Result1_Proj756, 11);
+    ext_grs_edge_t *e_pos1_139 = ext_grs_act_add_edge(pattern, "pos1_139", 0, n_Load919, n_Vector_Result12_Proj921, 12);
+    ext_grs_edge_t *e_e89 = ext_grs_act_add_edge(pattern, "e89", ext_grs_NO_EDGE_POS, n_Const764, n_MultipleAdd5717, 13);
+    ext_grs_edge_t *e_pos1_132 = ext_grs_act_add_edge(pattern, "pos1_132", 0, n_Load844, n_Vector_Result7_Proj846, 14);
+    ext_grs_edge_t *e_e123 = ext_grs_act_add_edge(pattern, "e123", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5707, 15);
+    ext_grs_edge_t *e_e122 = ext_grs_act_add_edge(pattern, "e122", ext_grs_NO_EDGE_POS, n_Const839, n_MultipleAdd5707, 16);
+    ext_grs_edge_t *e_pos1_88 = ext_grs_act_add_edge(pattern, "pos1_88", 0, n_Load739, n_Proj740, 17);
+    ext_grs_edge_t *e_pos1_87 = ext_grs_act_add_edge(pattern, "pos1_87", 0, n_Load814, n_Proj815, 18);
+    ext_grs_edge_t *e_pos1_86 = ext_grs_act_add_edge(pattern, "pos1_86", 0, n_Load904, n_Vector_Result11_Proj906, 19);
+    ext_grs_edge_t *e_pos2_109 = ext_grs_act_add_edge(pattern, "pos2_109", 1, n_MultipleAdd5717, n_Load769, 20);
+    ext_grs_edge_t *e_pos1_84 = ext_grs_act_add_edge(pattern, "pos1_84", 0, n_Load739, n_Vector_Result0_Proj741, 21);
+    ext_grs_edge_t *e_e129 = ext_grs_act_add_edge(pattern, "e129", ext_grs_NO_EDGE_POS, n_Const899, n_MultipleAdd5699, 22);
+    ext_grs_edge_t *e_pos2_110 = ext_grs_act_add_edge(pattern, "pos2_110", 1, n_MultipleAdd5695, n_Load934, 23);
+    ext_grs_edge_t *e_pos1_162 = ext_grs_act_add_edge(pattern, "pos1_162", 0, n_Load919, n_Proj920, 24);
+    ext_grs_edge_t *e_e111 = ext_grs_act_add_edge(pattern, "e111", ext_grs_NO_EDGE_POS, n_Const854, n_MultipleAdd5705, 25);
+    ext_grs_edge_t *e_e112 = ext_grs_act_add_edge(pattern, "e112", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5705, 26);
+    ext_grs_edge_t *e_e118 = ext_grs_act_add_edge(pattern, "e118", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5723, 27);
+    ext_grs_edge_t *e_e115 = ext_grs_act_add_edge(pattern, "e115", ext_grs_NO_EDGE_POS, n_Const914, n_MultipleAdd5697, 28);
+    ext_grs_edge_t *e_e117 = ext_grs_act_add_edge(pattern, "e117", ext_grs_NO_EDGE_POS, n_Const727, n_MultipleAdd5723, 29);
+    ext_grs_edge_t *e_e116 = ext_grs_act_add_edge(pattern, "e116", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5697, 30);
+    ext_grs_edge_t *e_pos2_126 = ext_grs_act_add_edge(pattern, "pos2_126", 1, n_MultipleAdd5711, n_Load814, 31);
+    ext_grs_edge_t *e_pos1_159 = ext_grs_act_add_edge(pattern, "pos1_159", 0, n_Load829, n_Vector_Result6_Proj831, 32);
+    ext_grs_edge_t *e_pos2_124 = ext_grs_act_add_edge(pattern, "pos2_124", 1, n_MultipleAdd5713, n_Load799, 33);
+    ext_grs_edge_t *e_pos1_152 = ext_grs_act_add_edge(pattern, "pos1_152", 0, n_Load949, n_Vector_Result14_Proj951, 34);
+    ext_grs_edge_t *e_pos1_153 = ext_grs_act_add_edge(pattern, "pos1_153", 0, n_Load964, n_Vector_Result15_Proj966, 35);
+    ext_grs_edge_t *e_pos1_150 = ext_grs_act_add_edge(pattern, "pos1_150", 0, n_Load904, n_Proj905, 36);
+    ext_grs_edge_t *e_e107 = ext_grs_act_add_edge(pattern, "e107", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5695, 37);
+    ext_grs_edge_t *e_e106 = ext_grs_act_add_edge(pattern, "e106", ext_grs_NO_EDGE_POS, n_Const929, n_MultipleAdd5695, 38);
+    ext_grs_edge_t *e_e105 = ext_grs_act_add_edge(pattern, "e105", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5719, 39);
+    ext_grs_edge_t *e_e104 = ext_grs_act_add_edge(pattern, "e104", ext_grs_NO_EDGE_POS, n_Const735, n_MultipleAdd5719, 40);
+    ext_grs_edge_t *e_pos1_108 = ext_grs_act_add_edge(pattern, "pos1_108", 0, n_Load949, n_Proj950, 41);
+    ext_grs_edge_t *e_e141 = ext_grs_act_add_edge(pattern, "e141", ext_grs_NO_EDGE_POS, n_Const809, n_MultipleAdd5711, 42);
+    ext_grs_edge_t *e_e142 = ext_grs_act_add_edge(pattern, "e142", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5711, 43);
+    ext_grs_edge_t *e_pos2_131 = ext_grs_act_add_edge(pattern, "pos2_131", 1, n_MultipleAdd5701, n_Load889, 44);
+    ext_grs_edge_t *e_e148 = ext_grs_act_add_edge(pattern, "e148", ext_grs_NO_EDGE_POS, n_Const794, n_MultipleAdd5713, 45);
+    ext_grs_edge_t *e_e149 = ext_grs_act_add_edge(pattern, "e149", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5713, 46);
+    ext_grs_edge_t *e_pos2_138 = ext_grs_act_add_edge(pattern, "pos2_138", 1, n_MultipleAdd5707, n_Load844, 47);
+    ext_grs_edge_t *e_pos1_100 = ext_grs_act_add_edge(pattern, "pos1_100", 0, n_Load754, n_Proj755, 48);
+    ext_grs_edge_t *e_pos1_101 = ext_grs_act_add_edge(pattern, "pos1_101", 0, n_Load769, n_Vector_Result2_Proj771, 49);
+    ext_grs_edge_t *e_pos0_160 = ext_grs_act_add_edge(pattern, "pos0_160", -1, n_Vector_op_Block, n_Load964, 50);
+    ext_grs_edge_t *e_pos1_103 = ext_grs_act_add_edge(pattern, "pos1_103", 0, n_Load934, n_Vector_Result13_Proj936, 51);
+    ext_grs_edge_t *e_e156 = ext_grs_act_add_edge(pattern, "e156", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5715, 52);
+    ext_grs_edge_t *e_e157 = ext_grs_act_add_edge(pattern, "e157", ext_grs_NO_EDGE_POS, n_Const959, n_MultipleAdd5691, 53);
+    ext_grs_edge_t *e_pos2_140 = ext_grs_act_add_edge(pattern, "pos2_140", 1, n_MultipleAdd5719, n_Load754, 54);
+    ext_grs_edge_t *e_e155 = ext_grs_act_add_edge(pattern, "e155", ext_grs_NO_EDGE_POS, n_Const779, n_MultipleAdd5715, 55);
+    ext_grs_edge_t *e_pos2_143 = ext_grs_act_add_edge(pattern, "pos2_143", 1, n_MultipleAdd5697, n_Load919, 56);
+    ext_grs_edge_t *e_e158 = ext_grs_act_add_edge(pattern, "e158", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5691, 57);
+    ext_grs_edge_t *e_pos2_147 = ext_grs_act_add_edge(pattern, "pos2_147", 1, n_MultipleAdd5703, n_Load874, 58);
+    ext_grs_edge_t *e_pos2_151 = ext_grs_act_add_edge(pattern, "pos2_151", 1, n_MultipleAdd5715, n_Load784, 59);
+    ext_grs_edge_t *e_pos2_154 = ext_grs_act_add_edge(pattern, "pos2_154", 1, n_MultipleAdd5693, n_Load949, 60);
+    ext_grs_edge_t *e_e97 = ext_grs_act_add_edge(pattern, "e97", ext_grs_NO_EDGE_POS, n_Const869, n_MultipleAdd5703, 61);
+    ext_grs_edge_t *e_e98 = ext_grs_act_add_edge(pattern, "e98", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5703, 62);
+    ext_grs_edge_t *e_pos1_120 = ext_grs_act_add_edge(pattern, "pos1_120", 0, n_Load964, n_Proj965, 63);
+    ext_grs_edge_t *e_pos1_121 = ext_grs_act_add_edge(pattern, "pos1_121", 0, n_Load814, n_Vector_Result5_Proj816, 64);
+    ext_grs_edge_t *e_pos2_95 = ext_grs_act_add_edge(pattern, "pos2_95", 1, n_MultipleAdd5699, n_Load904, 65);
+    ext_grs_edge_t *e_pos1_94 = ext_grs_act_add_edge(pattern, "pos1_94", 0, n_Load934, n_Proj935, 66);
+    ext_grs_edge_t *e_pos1_96 = ext_grs_act_add_edge(pattern, "pos1_96", 0, n_Load859, n_Vector_Result8_Proj861, 67);
+    ext_grs_edge_t *e_pos2_91 = ext_grs_act_add_edge(pattern, "pos2_91", 1, n_MultipleAdd5723, n_Load739, 68);
+    ext_grs_edge_t *e_pos1_127 = ext_grs_act_add_edge(pattern, "pos1_127", 0, n_Load784, n_Proj785, 69);
+    ext_grs_edge_t *e_pos1_99 = ext_grs_act_add_edge(pattern, "pos1_99", 0, n_Load829, n_Proj830, 70);
+    ext_grs_edge_t *e_e90 = ext_grs_act_add_edge(pattern, "e90", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5717, 71);
+    ext_grs_edge_t *e_pos1_128 = ext_grs_act_add_edge(pattern, "pos1_128", 0, n_Load889, n_Vector_Result10_Proj891, 72);
+    ext_grs_edge_t *e_e93 = ext_grs_act_add_edge(pattern, "e93", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5693, 73);
+    ext_grs_edge_t *e_pos1_125 = ext_grs_act_add_edge(pattern, "pos1_125", 0, n_Load859, n_Proj860, 74);
+    ext_grs_edge_t *e_e92 = ext_grs_act_add_edge(pattern, "e92", ext_grs_NO_EDGE_POS, n_Const944, n_MultipleAdd5693, 75);
+    ext_grs_edge_t *e_pos2_161 = ext_grs_act_add_edge(pattern, "pos2_161", 1, n_MultipleAdd5691, n_Load964, 76);
+    ext_grs_edge_t *e_pos1_119 = ext_grs_act_add_edge(pattern, "pos1_119", 0, n_Load799, n_Vector_Result4_Proj801, 77);
+    ext_grs_edge_t *e_pos2_85 = ext_grs_act_add_edge(pattern, "pos2_85", 1, n_MultipleAdd5709, n_Load829, 78);
+    ext_grs_edge_t *e_pos1_113 = ext_grs_act_add_edge(pattern, "pos1_113", 0, n_Load844, n_Proj845, 79);
+    ext_grs_edge_t *e_pos1_114 = ext_grs_act_add_edge(pattern, "pos1_114", 0, n_Load769, n_Proj770, 80);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const944};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32999, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const727};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33002, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5701};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33005, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_Proj741};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33008, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj815};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33011, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result11_Proj906};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33014, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj740};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33017, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5717};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33020, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5693};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33023, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const959};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33026, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj935};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33029, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result8_Proj861};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33032, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5703};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33035, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const824};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33038, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj830};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33041, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj755};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33044, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result2_Proj771};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33047, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5719};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33050, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result13_Proj936};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33053, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5695};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33056, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj950};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33059, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const899};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33062, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5705};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33065, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj845};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33068, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj770};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33071, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const854};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33074, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5697};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33077, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5723};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33080, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result4_Proj801};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33083, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj965};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33086, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result5_Proj816};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33089, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const764};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33092, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5707};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33095, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const929};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33098, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj860};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33101, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj785};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33104, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result10_Proj891};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33107, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5699};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33110, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5709};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33113, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result7_Proj846};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33116, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const794};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33119, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj875};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33122, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj800};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33125, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const809};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33128, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result1_Proj756};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33131, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result12_Proj921};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33134, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const731};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33137, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5711};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33140, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj890};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33143, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result9_Proj876};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33146, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const839};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33149, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result3_Proj786};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33152, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5713};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33155, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const735};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33158, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const914};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33161, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj905};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33164, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result14_Proj951};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33167, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result15_Proj966};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33170, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const869};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33173, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5715};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33176, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5691};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33179, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result6_Proj831};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33182, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj920};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33185, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const779};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_33188, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Const764_1186 = ext_grs_act_add_node_to_keep(pattern, "Const764_1186", grs_op_Const, mode_Is, 0, n_Const764);
+       ext_grs_node_t *n_Const959_1187 = ext_grs_act_add_node_to_keep(pattern, "Const959_1187", grs_op_Const, mode_Is, 1, n_Const959);
+       ext_grs_node_t *n_Load874_1188 = ext_grs_act_add_node_to_keep(pattern, "Load874_1188", grs_op_Load, mode_T, 2, n_Load874);
+       ext_grs_node_t *n_VProj100_1189 = ext_grs_act_add_node_to_keep(pattern, "VProj100_1189", grs_op_VProj, mode_Bu, 82, n_Vector_Result1_Proj756);
+       ext_grs_node_t *n_VProj102_1190 = ext_grs_act_add_node_to_keep(pattern, "VProj102_1190", grs_op_VProj, mode_Bu, 83, n_Vector_Result12_Proj921);
+       ext_grs_node_t *n_MultipleAdd5723_1191 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5723_1191", grs_op_MultipleAdd, mode_P, 5, n_MultipleAdd5723);
+       ext_grs_node_t *n_VProj108_1192 = ext_grs_act_add_node_to_keep(pattern, "VProj108_1192", grs_op_VProj, mode_Bu, 84, n_Vector_Result14_Proj951);
+       ext_grs_node_t *n_Proj935_1193 = ext_grs_act_add_node_to_keep(pattern, "Proj935_1193", grs_op_Proj, mode_M, 7, n_Proj935);
+       ext_grs_node_t *n_Proj740_1194 = ext_grs_act_add_node_to_keep(pattern, "Proj740_1194", grs_op_Proj, mode_M, 8, n_Proj740);
+       ext_grs_node_t *n_Const727_1195 = ext_grs_act_add_node_to_keep(pattern, "Const727_1195", grs_op_Const, mode_Is, 9, n_Const727);
+       ext_grs_node_t *n_MultipleAdd5719_1196 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5719_1196", grs_op_MultipleAdd, mode_P, 10, n_MultipleAdd5719);
+       ext_grs_node_t *n_Load934_1197 = ext_grs_act_add_node_to_keep(pattern, "Load934_1197", grs_op_Load, mode_T, 11, n_Load934);
+       ext_grs_node_t *n_MultipleAdd5717_1198 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5717_1198", grs_op_MultipleAdd, mode_P, 12, n_MultipleAdd5717);
+       ext_grs_node_t *n_Load739_1199 = ext_grs_act_add_node_to_keep(pattern, "Load739_1199", grs_op_Load, mode_T, 13, n_Load739);
+       ext_grs_node_t *n_Const929_1200 = ext_grs_act_add_node_to_keep(pattern, "Const929_1200", grs_op_Const, mode_Is, 14, n_Const929);
+       ext_grs_node_t *n_Load829_1201 = ext_grs_act_add_node_to_keep(pattern, "Load829_1201", grs_op_Load, mode_T, 15, n_Load829);
+       ext_grs_node_t *n_VProj98_1202 = ext_grs_act_add_node_to_keep(pattern, "VProj98_1202", grs_op_VProj, mode_Bu, 85, n_Vector_Result7_Proj846);
+       ext_grs_node_t *n_Proj875_1203 = ext_grs_act_add_node_to_keep(pattern, "Proj875_1203", grs_op_Proj, mode_M, 17, n_Proj875);
+       ext_grs_node_t *n_Const869_1204 = ext_grs_act_add_node_to_keep(pattern, "Const869_1204", grs_op_Const, mode_Is, 18, n_Const869);
+       ext_grs_node_t *n_Arg_0_1205 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1205", grs_op_VectorBase, mode_ANY, 19, n_Arg_0);
+       ext_grs_node_t *n_Const854_1206 = ext_grs_act_add_node_to_keep(pattern, "Const854_1206", grs_op_Const, mode_Is, 20, n_Const854);
+       ext_grs_node_t *n_Load844_1207 = ext_grs_act_add_node_to_keep(pattern, "Load844_1207", grs_op_Load, mode_T, 21, n_Load844);
+       ext_grs_node_t *n_Const824_1208 = ext_grs_act_add_node_to_keep(pattern, "Const824_1208", grs_op_Const, mode_Is, 22, n_Const824);
+       ext_grs_node_t *n_Proj890_1209 = ext_grs_act_add_node_to_keep(pattern, "Proj890_1209", grs_op_Proj, mode_M, 23, n_Proj890);
+       ext_grs_node_t *n_VProj104_1210 = ext_grs_act_add_node_to_keep(pattern, "VProj104_1210", grs_op_VProj, mode_Bu, 86, n_Vector_Result9_Proj876);
+       ext_grs_node_t *n_MultipleAdd5713_1211 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5713_1211", grs_op_MultipleAdd, mode_P, 24, n_MultipleAdd5713);
+       ext_grs_node_t *n_MultipleAdd5715_1212 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5715_1212", grs_op_MultipleAdd, mode_P, 26, n_MultipleAdd5715);
+       ext_grs_node_t *n_Const899_1213 = ext_grs_act_add_node_to_keep(pattern, "Const899_1213", grs_op_Const, mode_Is, 27, n_Const899);
+       ext_grs_node_t *n_Load889_1214 = ext_grs_act_add_node_to_keep(pattern, "Load889_1214", grs_op_Load, mode_T, 28, n_Load889);
+       ext_grs_node_t *n_Proj800_1215 = ext_grs_act_add_node_to_keep(pattern, "Proj800_1215", grs_op_Proj, mode_M, 29, n_Proj800);
+       ext_grs_node_t *n_VProj90_1216 = ext_grs_act_add_node_to_keep(pattern, "VProj90_1216", grs_op_VProj, mode_Bu, 87, n_Vector_Result13_Proj936);
+       ext_grs_node_t *n_MultipleAdd5711_1217 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5711_1217", grs_op_MultipleAdd, mode_P, 31, n_MultipleAdd5711);
+       ext_grs_node_t *n_MultipleAdd5693_1218 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5693_1218", grs_op_MultipleAdd, mode_P, 33, n_MultipleAdd5693);
+       ext_grs_node_t *n_Load949_1219 = ext_grs_act_add_node_to_keep(pattern, "Load949_1219", grs_op_Load, mode_T, 32, n_Load949);
+       ext_grs_node_t *n_Proj785_1220 = ext_grs_act_add_node_to_keep(pattern, "Proj785_1220", grs_op_Proj, mode_M, 35, n_Proj785);
+       ext_grs_node_t *n_MultipleAdd5691_1221 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5691_1221", grs_op_MultipleAdd, mode_P, 34, n_MultipleAdd5691);
+       ext_grs_node_t *n_MultipleAdd5707_1222 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5707_1222", grs_op_MultipleAdd, mode_P, 39, n_MultipleAdd5707);
+       ext_grs_node_t *n_MultipleAdd5697_1223 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5697_1223", grs_op_MultipleAdd, mode_P, 38, n_MultipleAdd5697);
+       ext_grs_node_t *n_Load799_1224 = ext_grs_act_add_node_to_keep(pattern, "Load799_1224", grs_op_Load, mode_T, 36, n_Load799);
+       ext_grs_node_t *n_VProj86_1225 = ext_grs_act_add_node_to_keep(pattern, "VProj86_1225", grs_op_VProj, mode_Bu, 88, n_Vector_Result8_Proj861);
+       ext_grs_node_t *n_VProj112_1226 = ext_grs_act_add_node_to_keep(pattern, "VProj112_1226", grs_op_VProj, mode_Bu, 89, n_Vector_Result6_Proj831);
+       ext_grs_node_t *n_Proj845_1227 = ext_grs_act_add_node_to_keep(pattern, "Proj845_1227", grs_op_Proj, mode_M, 45, n_Proj845);
+       ext_grs_node_t *n_Proj950_1228 = ext_grs_act_add_node_to_keep(pattern, "Proj950_1228", grs_op_Proj, mode_M, 44, n_Proj950);
+       ext_grs_node_t *n_MultipleAdd5695_1229 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5695_1229", grs_op_MultipleAdd, mode_P, 43, n_MultipleAdd5695);
+       ext_grs_node_t *n_MultipleAdd5709_1230 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5709_1230", grs_op_MultipleAdd, mode_P, 41, n_MultipleAdd5709);
+       ext_grs_node_t *n_VProj84_1231 = ext_grs_act_add_node_to_keep(pattern, "VProj84_1231", grs_op_VProj, mode_Bu, 90, n_Vector_Result11_Proj906);
+       ext_grs_node_t *n_VProj94_1232 = ext_grs_act_add_node_to_keep(pattern, "VProj94_1232", grs_op_VProj, mode_Bu, 91, n_Vector_Result5_Proj816);
+       ext_grs_node_t *n_Load904_1233 = ext_grs_act_add_node_to_keep(pattern, "Load904_1233", grs_op_Load, mode_T, 47, n_Load904);
+       ext_grs_node_t *n_Load784_1234 = ext_grs_act_add_node_to_keep(pattern, "Load784_1234", grs_op_Load, mode_T, 48, n_Load784);
+       ext_grs_node_t *n_MultipleAdd5699_1235 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5699_1235", grs_op_MultipleAdd, mode_P, 50, n_MultipleAdd5699);
+       ext_grs_node_t *n_Proj905_1236 = ext_grs_act_add_node_to_keep(pattern, "Proj905_1236", grs_op_Proj, mode_M, 49, n_Proj905);
+       ext_grs_node_t *n_Const794_1237 = ext_grs_act_add_node_to_keep(pattern, "Const794_1237", grs_op_Const, mode_Is, 51, n_Const794);
+       ext_grs_node_t *n_Const914_1238 = ext_grs_act_add_node_to_keep(pattern, "Const914_1238", grs_op_Const, mode_Is, 52, n_Const914);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 92);
+       ext_grs_node_t *n_Load859_1239 = ext_grs_act_add_node_to_keep(pattern, "Load859_1239", grs_op_Load, mode_T, 53, n_Load859);
+       ext_grs_node_t *n_Const944_1240 = ext_grs_act_add_node_to_keep(pattern, "Const944_1240", grs_op_Const, mode_Is, 54, n_Const944);
+       ext_grs_node_t *n_Proj860_1241 = ext_grs_act_add_node_to_keep(pattern, "Proj860_1241", grs_op_Proj, mode_M, 55, n_Proj860);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 93);
+       ext_grs_node_t *n_MultipleAdd5701_1242 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5701_1242", grs_op_MultipleAdd, mode_P, 56, n_MultipleAdd5701);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 94);
+       ext_grs_node_t *n_MultipleAdd5705_1243 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5705_1243", grs_op_MultipleAdd, mode_P, 57, n_MultipleAdd5705);
+       ext_grs_node_t *n_MultipleAdd5703_1244 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5703_1244", grs_op_MultipleAdd, mode_P, 58, n_MultipleAdd5703);
+       ext_grs_node_t *n_Bad82 = ext_grs_act_add_node(pattern, "Bad82", grs_op_Bad, mode_ANY, 95);
+       ext_grs_node_t *n_VProj92_1245 = ext_grs_act_add_node_to_keep(pattern, "VProj92_1245", grs_op_VProj, mode_Bu, 96, n_Vector_Result4_Proj801);
+       ext_grs_node_t *n_VProj82_1246 = ext_grs_act_add_node_to_keep(pattern, "VProj82_1246", grs_op_VProj, mode_Bu, 97, n_Vector_Result0_Proj741);
+       ext_grs_node_t *n_Proj815_1247 = ext_grs_act_add_node_to_keep(pattern, "Proj815_1247", grs_op_Proj, mode_M, 61, n_Proj815);
+       ext_grs_node_t *n_Proj755_1248 = ext_grs_act_add_node_to_keep(pattern, "Proj755_1248", grs_op_Proj, mode_M, 62, n_Proj755);
+       ext_grs_node_t *n_Load814_1249 = ext_grs_act_add_node_to_keep(pattern, "Load814_1249", grs_op_Load, mode_T, 63, n_Load814);
+       ext_grs_node_t *n_VProj106_1250 = ext_grs_act_add_node_to_keep(pattern, "VProj106_1250", grs_op_VProj, mode_Bu, 98, n_Vector_Result3_Proj786);
+       ext_grs_node_t *n_Load754_1251 = ext_grs_act_add_node_to_keep(pattern, "Load754_1251", grs_op_Load, mode_T, 65, n_Load754);
+       ext_grs_node_t *n_Const809_1252 = ext_grs_act_add_node_to_keep(pattern, "Const809_1252", grs_op_Const, mode_Is, 66, n_Const809);
+       ext_grs_node_t *n_Const779_1253 = ext_grs_act_add_node_to_keep(pattern, "Const779_1253", grs_op_Const, mode_Is, 67, n_Const779);
+       ext_grs_node_t *n_Vector_op_Block_1254 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1254", grs_op_Block, mode_BB, 68, n_Vector_op_Block);
+       ext_grs_node_t *n_Load919_1255 = ext_grs_act_add_node_to_keep(pattern, "Load919_1255", grs_op_Load, mode_T, 70, n_Load919);
+       ext_grs_node_t *n_Load964_1256 = ext_grs_act_add_node_to_keep(pattern, "Load964_1256", grs_op_Load, mode_T, 69, n_Load964);
+       ext_grs_node_t *n_VProj96_1257 = ext_grs_act_add_node_to_keep(pattern, "VProj96_1257", grs_op_VProj, mode_Bu, 99, n_Vector_Result10_Proj891);
+       ext_grs_node_t *n_Const735_1258 = ext_grs_act_add_node_to_keep(pattern, "Const735_1258", grs_op_Const, mode_Is, 72, n_Const735);
+       ext_grs_node_t *n_VProj88_1259 = ext_grs_act_add_node_to_keep(pattern, "VProj88_1259", grs_op_VProj, mode_Bu, 100, n_Vector_Result2_Proj771);
+       ext_grs_node_t *n_Const731_1260 = ext_grs_act_add_node_to_keep(pattern, "Const731_1260", grs_op_Const, mode_Is, 74, n_Const731);
+       ext_grs_node_t *n_Proj965_1261 = ext_grs_act_add_node_to_keep(pattern, "Proj965_1261", grs_op_Proj, mode_M, 77, n_Proj965);
+       ext_grs_node_t *n_Proj770_1262 = ext_grs_act_add_node_to_keep(pattern, "Proj770_1262", grs_op_Proj, mode_M, 76, n_Proj770);
+       ext_grs_node_t *n_Proj830_1263 = ext_grs_act_add_node_to_keep(pattern, "Proj830_1263", grs_op_Proj, mode_M, 75, n_Proj830);
+       ext_grs_node_t *n_Load769_1264 = ext_grs_act_add_node_to_keep(pattern, "Load769_1264", grs_op_Load, mode_T, 78, n_Load769);
+       ext_grs_node_t *n_VProj110_1265 = ext_grs_act_add_node_to_keep(pattern, "VProj110_1265", grs_op_VProj, mode_Bu, 101, n_Vector_Result15_Proj966);
+       ext_grs_node_t *n_Proj920_1266 = ext_grs_act_add_node_to_keep(pattern, "Proj920_1266", grs_op_Proj, mode_M, 80, n_Proj920);
+       ext_grs_node_t *n_Const839_1267 = ext_grs_act_add_node_to_keep(pattern, "Const839_1267", grs_op_Const, mode_Is, 81, n_Const839);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_144_1268 = ext_grs_act_add_edge_to_keep(pattern, "pos1_144_1268", 0, n_Load889_1214, n_Proj890_1209, 2, e_pos1_144);
+       ext_grs_edge_t *e_e130_1269 = ext_grs_act_add_edge_to_keep(pattern, "e130_1269", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5699_1235, 3, e_e130);
+       ext_grs_edge_t *e_e133_1270 = ext_grs_act_add_edge_to_keep(pattern, "e133_1270", ext_grs_NO_EDGE_POS, n_Const824_1208, n_MultipleAdd5709_1230, 4, e_e133);
+       ext_grs_edge_t *e_e134_1271 = ext_grs_act_add_edge_to_keep(pattern, "e134_1271", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5709_1230, 5, e_e134);
+       ext_grs_edge_t *e_e83_1272 = ext_grs_act_add_edge_to_keep(pattern, "e83_1272", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5701_1242, 6, e_e83);
+       ext_grs_edge_t *e_e82_1273 = ext_grs_act_add_edge_to_keep(pattern, "e82_1273", ext_grs_NO_EDGE_POS, n_Const731_1260, n_MultipleAdd5701_1242, 7, e_e82);
+       ext_grs_edge_t *e_pos2_102_1274 = ext_grs_act_add_edge_to_keep(pattern, "pos2_102_1274", 1, n_MultipleAdd5705_1243, n_Load859_1239, 9, e_pos2_102);
+       ext_grs_edge_t *e_pos1_136_1275 = ext_grs_act_add_edge_to_keep(pattern, "pos1_136_1275", 0, n_Load799_1224, n_Proj800_1215, 8, e_pos1_136);
+       ext_grs_edge_t *e_pos1_135_1276 = ext_grs_act_add_edge_to_keep(pattern, "pos1_135_1276", 0, n_Load874_1188, n_Proj875_1203, 10, e_pos1_135);
+       ext_grs_edge_t *e_e89_1277 = ext_grs_act_add_edge_to_keep(pattern, "e89_1277", ext_grs_NO_EDGE_POS, n_Const764_1186, n_MultipleAdd5717_1198, 13, e_e89);
+       ext_grs_edge_t *e_e123_1278 = ext_grs_act_add_edge_to_keep(pattern, "e123_1278", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5707_1222, 15, e_e123);
+       ext_grs_edge_t *e_e122_1279 = ext_grs_act_add_edge_to_keep(pattern, "e122_1279", ext_grs_NO_EDGE_POS, n_Const839_1267, n_MultipleAdd5707_1222, 16, e_e122);
+       ext_grs_edge_t *e_pos1_88_1280 = ext_grs_act_add_edge_to_keep(pattern, "pos1_88_1280", 0, n_Load739_1199, n_Proj740_1194, 17, e_pos1_88);
+       ext_grs_edge_t *e_pos1_87_1281 = ext_grs_act_add_edge_to_keep(pattern, "pos1_87_1281", 0, n_Load814_1249, n_Proj815_1247, 18, e_pos1_87);
+       ext_grs_edge_t *e_pos2_109_1282 = ext_grs_act_add_edge_to_keep(pattern, "pos2_109_1282", 1, n_MultipleAdd5717_1198, n_Load769_1264, 20, e_pos2_109);
+       ext_grs_edge_t *e_e129_1283 = ext_grs_act_add_edge_to_keep(pattern, "e129_1283", ext_grs_NO_EDGE_POS, n_Const899_1213, n_MultipleAdd5699_1235, 22, e_e129);
+       ext_grs_edge_t *e_pos1_168_1284 = ext_grs_act_add_edge(pattern, "pos1_168_1284", 0, n_Vector_op, n_Vector_op_ProjM, 81);
+       ext_grs_edge_t *e_pos1_166_1285 = ext_grs_act_add_edge(pattern, "pos1_166_1285", 0, n_MultipleAdd5723_1191, n_Vector_op, 82);
+       ext_grs_edge_t *e_pos2_110_1286 = ext_grs_act_add_edge_to_keep(pattern, "pos2_110_1286", 1, n_MultipleAdd5695_1229, n_Load934_1197, 23, e_pos2_110);
+       ext_grs_edge_t *e_pos1_165_1287 = ext_grs_act_add_edge(pattern, "pos1_165_1287", 0, n_Vector_op, n_Vector_op_ProjData, 83);
+       ext_grs_edge_t *e_pos1_162_1288 = ext_grs_act_add_edge_to_keep(pattern, "pos1_162_1288", 0, n_Load919_1255, n_Proj920_1266, 24, e_pos1_162);
+       ext_grs_edge_t *e_e111_1289 = ext_grs_act_add_edge_to_keep(pattern, "e111_1289", ext_grs_NO_EDGE_POS, n_Const854_1206, n_MultipleAdd5705_1243, 25, e_e111);
+       ext_grs_edge_t *e_e112_1290 = ext_grs_act_add_edge_to_keep(pattern, "e112_1290", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5705_1243, 26, e_e112);
+       ext_grs_edge_t *e_e118_1291 = ext_grs_act_add_edge_to_keep(pattern, "e118_1291", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5723_1191, 27, e_e118);
+       ext_grs_edge_t *e_e115_1292 = ext_grs_act_add_edge_to_keep(pattern, "e115_1292", ext_grs_NO_EDGE_POS, n_Const914_1238, n_MultipleAdd5697_1223, 28, e_e115);
+       ext_grs_edge_t *e_e117_1293 = ext_grs_act_add_edge_to_keep(pattern, "e117_1293", ext_grs_NO_EDGE_POS, n_Const727_1195, n_MultipleAdd5723_1191, 29, e_e117);
+       ext_grs_edge_t *e_e116_1294 = ext_grs_act_add_edge_to_keep(pattern, "e116_1294", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5697_1223, 30, e_e116);
+       ext_grs_edge_t *e_pos2_126_1295 = ext_grs_act_add_edge_to_keep(pattern, "pos2_126_1295", 1, n_MultipleAdd5711_1217, n_Load814_1249, 31, e_pos2_126);
+       ext_grs_edge_t *e_pos2_124_1296 = ext_grs_act_add_edge_to_keep(pattern, "pos2_124_1296", 1, n_MultipleAdd5713_1211, n_Load799_1224, 33, e_pos2_124);
+       ext_grs_edge_t *e_pos1_150_1297 = ext_grs_act_add_edge_to_keep(pattern, "pos1_150_1297", 0, n_Load904_1233, n_Proj905_1236, 36, e_pos1_150);
+       ext_grs_edge_t *e_e107_1298 = ext_grs_act_add_edge_to_keep(pattern, "e107_1298", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5695_1229, 37, e_e107);
+       ext_grs_edge_t *e_e106_1299 = ext_grs_act_add_edge_to_keep(pattern, "e106_1299", ext_grs_NO_EDGE_POS, n_Const929_1200, n_MultipleAdd5695_1229, 38, e_e106);
+       ext_grs_edge_t *e_e105_1300 = ext_grs_act_add_edge_to_keep(pattern, "e105_1300", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5719_1196, 39, e_e105);
+       ext_grs_edge_t *e_e104_1301 = ext_grs_act_add_edge_to_keep(pattern, "e104_1301", ext_grs_NO_EDGE_POS, n_Const735_1258, n_MultipleAdd5719_1196, 40, e_e104);
+       ext_grs_edge_t *e_pos1_182_1302 = ext_grs_act_add_edge(pattern, "pos1_182_1302", 0, n_Vector_op_ProjData, n_VProj106_1250, 84);
+       ext_grs_edge_t *e_pos1_108_1303 = ext_grs_act_add_edge_to_keep(pattern, "pos1_108_1303", 0, n_Load949_1219, n_Proj950_1228, 41, e_pos1_108);
+       ext_grs_edge_t *e_pos1_183_1304 = ext_grs_act_add_edge(pattern, "pos1_183_1304", 0, n_Vector_op_ProjData, n_VProj108_1192, 85);
+       ext_grs_edge_t *e_e141_1305 = ext_grs_act_add_edge_to_keep(pattern, "e141_1305", ext_grs_NO_EDGE_POS, n_Const809_1252, n_MultipleAdd5711_1217, 42, e_e141);
+       ext_grs_edge_t *e_pos1_180_1306 = ext_grs_act_add_edge(pattern, "pos1_180_1306", 0, n_Vector_op_ProjData, n_VProj102_1190, 86);
+       ext_grs_edge_t *e_e142_1307 = ext_grs_act_add_edge_to_keep(pattern, "e142_1307", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5711_1217, 43, e_e142);
+       ext_grs_edge_t *e_pos1_181_1308 = ext_grs_act_add_edge(pattern, "pos1_181_1308", 0, n_Vector_op_ProjData, n_VProj104_1210, 87);
+       ext_grs_edge_t *e_pos2_131_1309 = ext_grs_act_add_edge_to_keep(pattern, "pos2_131_1309", 1, n_MultipleAdd5701_1242, n_Load889_1214, 44, e_pos2_131);
+       ext_grs_edge_t *e_pos1_184_1310 = ext_grs_act_add_edge(pattern, "pos1_184_1310", 0, n_Vector_op_ProjData, n_VProj110_1265, 88);
+       ext_grs_edge_t *e_pos1_185_1311 = ext_grs_act_add_edge(pattern, "pos1_185_1311", 0, n_Vector_op_ProjData, n_VProj112_1226, 89);
+       ext_grs_edge_t *e_e148_1312 = ext_grs_act_add_edge_to_keep(pattern, "e148_1312", ext_grs_NO_EDGE_POS, n_Const794_1237, n_MultipleAdd5713_1211, 45, e_e148);
+       ext_grs_edge_t *e_e149_1313 = ext_grs_act_add_edge_to_keep(pattern, "e149_1313", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5713_1211, 46, e_e149);
+       ext_grs_edge_t *e_pos2_138_1314 = ext_grs_act_add_edge_to_keep(pattern, "pos2_138_1314", 1, n_MultipleAdd5707_1222, n_Load844_1207, 47, e_pos2_138);
+       ext_grs_edge_t *e_pos0_169_1315 = ext_grs_act_add_edge(pattern, "pos0_169_1315", -1, n_Vector_op_Block_1254, n_Vector_op_ProjM, 90);
+       ext_grs_edge_t *e_pos1_100_1316 = ext_grs_act_add_edge_to_keep(pattern, "pos1_100_1316", 0, n_Load754_1251, n_Proj755_1248, 48, e_pos1_100);
+       ext_grs_edge_t *e_pos0_160_1317 = ext_grs_act_add_edge_to_keep(pattern, "pos0_160_1317", -1, n_Vector_op_Block_1254, n_Load964_1256, 50, e_pos0_160);
+       ext_grs_edge_t *e_pos0_163_1318 = ext_grs_act_add_edge(pattern, "pos0_163_1318", -1, n_Vector_op_Block_1254, n_Vector_op, 91);
+       ext_grs_edge_t *e_pos0_164_1319 = ext_grs_act_add_edge(pattern, "pos0_164_1319", -1, n_Vector_op_Block_1254, n_Vector_op_ProjData, 92);
+       ext_grs_edge_t *e_pos1_170_1320 = ext_grs_act_add_edge(pattern, "pos1_170_1320", 0, n_Vector_op_ProjData, n_VProj82_1246, 93);
+       ext_grs_edge_t *e_pos1_171_1321 = ext_grs_act_add_edge(pattern, "pos1_171_1321", 0, n_Vector_op_ProjData, n_VProj84_1231, 94);
+       ext_grs_edge_t *e_pos1_172_1322 = ext_grs_act_add_edge(pattern, "pos1_172_1322", 0, n_Vector_op_ProjData, n_VProj86_1225, 95);
+       ext_grs_edge_t *e_e156_1323 = ext_grs_act_add_edge_to_keep(pattern, "e156_1323", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5715_1212, 52, e_e156);
+       ext_grs_edge_t *e_pos1_173_1324 = ext_grs_act_add_edge(pattern, "pos1_173_1324", 0, n_Vector_op_ProjData, n_VProj88_1259, 96);
+       ext_grs_edge_t *e_pos2_140_1325 = ext_grs_act_add_edge_to_keep(pattern, "pos2_140_1325", 1, n_MultipleAdd5719_1196, n_Load754_1251, 54, e_pos2_140);
+       ext_grs_edge_t *e_e157_1326 = ext_grs_act_add_edge_to_keep(pattern, "e157_1326", ext_grs_NO_EDGE_POS, n_Const959_1187, n_MultipleAdd5691_1221, 53, e_e157);
+       ext_grs_edge_t *e_pos1_174_1327 = ext_grs_act_add_edge(pattern, "pos1_174_1327", 0, n_Vector_op_ProjData, n_VProj90_1216, 97);
+       ext_grs_edge_t *e_pos1_175_1328 = ext_grs_act_add_edge(pattern, "pos1_175_1328", 0, n_Vector_op_ProjData, n_VProj92_1245, 98);
+       ext_grs_edge_t *e_e155_1329 = ext_grs_act_add_edge_to_keep(pattern, "e155_1329", ext_grs_NO_EDGE_POS, n_Const779_1253, n_MultipleAdd5715_1212, 55, e_e155);
+       ext_grs_edge_t *e_pos1_176_1330 = ext_grs_act_add_edge(pattern, "pos1_176_1330", 0, n_Vector_op_ProjData, n_VProj94_1232, 99);
+       ext_grs_edge_t *e_pos2_143_1331 = ext_grs_act_add_edge_to_keep(pattern, "pos2_143_1331", 1, n_MultipleAdd5697_1223, n_Load919_1255, 56, e_pos2_143);
+       ext_grs_edge_t *e_pos1_177_1332 = ext_grs_act_add_edge(pattern, "pos1_177_1332", 0, n_Vector_op_ProjData, n_VProj96_1257, 100);
+       ext_grs_edge_t *e_pos1_178_1333 = ext_grs_act_add_edge(pattern, "pos1_178_1333", 0, n_Vector_op_ProjData, n_VProj98_1202, 101);
+       ext_grs_edge_t *e_e158_1334 = ext_grs_act_add_edge_to_keep(pattern, "e158_1334", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5691_1221, 57, e_e158);
+       ext_grs_edge_t *e_pos1_179_1335 = ext_grs_act_add_edge(pattern, "pos1_179_1335", 0, n_Vector_op_ProjData, n_VProj100_1189, 102);
+       ext_grs_edge_t *e_pos2_147_1336 = ext_grs_act_add_edge_to_keep(pattern, "pos2_147_1336", 1, n_MultipleAdd5703_1244, n_Load874_1188, 58, e_pos2_147);
+       ext_grs_edge_t *e_pos2_151_1337 = ext_grs_act_add_edge_to_keep(pattern, "pos2_151_1337", 1, n_MultipleAdd5715_1212, n_Load784_1234, 59, e_pos2_151);
+       ext_grs_edge_t *e_pos2_154_1338 = ext_grs_act_add_edge_to_keep(pattern, "pos2_154_1338", 1, n_MultipleAdd5693_1218, n_Load949_1219, 60, e_pos2_154);
+       ext_grs_edge_t *e_e97_1339 = ext_grs_act_add_edge_to_keep(pattern, "e97_1339", ext_grs_NO_EDGE_POS, n_Const869_1204, n_MultipleAdd5703_1244, 61, e_e97);
+       ext_grs_edge_t *e_e98_1340 = ext_grs_act_add_edge_to_keep(pattern, "e98_1340", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5703_1244, 62, e_e98);
+       ext_grs_edge_t *e_pos1_120_1341 = ext_grs_act_add_edge_to_keep(pattern, "pos1_120_1341", 0, n_Load964_1256, n_Proj965_1261, 63, e_pos1_120);
+       ext_grs_edge_t *e_pos2_95_1342 = ext_grs_act_add_edge_to_keep(pattern, "pos2_95_1342", 1, n_MultipleAdd5699_1235, n_Load904_1233, 65, e_pos2_95);
+       ext_grs_edge_t *e_pos1_94_1343 = ext_grs_act_add_edge_to_keep(pattern, "pos1_94_1343", 0, n_Load934_1197, n_Proj935_1193, 66, e_pos1_94);
+       ext_grs_edge_t *e_pos2_91_1344 = ext_grs_act_add_edge_to_keep(pattern, "pos2_91_1344", 1, n_MultipleAdd5723_1191, n_Load739_1199, 68, e_pos2_91);
+       ext_grs_edge_t *e_e90_1345 = ext_grs_act_add_edge_to_keep(pattern, "e90_1345", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5717_1198, 71, e_e90);
+       ext_grs_edge_t *e_pos1_99_1346 = ext_grs_act_add_edge_to_keep(pattern, "pos1_99_1346", 0, n_Load829_1201, n_Proj830_1263, 70, e_pos1_99);
+       ext_grs_edge_t *e_pos1_127_1347 = ext_grs_act_add_edge_to_keep(pattern, "pos1_127_1347", 0, n_Load784_1234, n_Proj785_1220, 69, e_pos1_127);
+       ext_grs_edge_t *e_e93_1348 = ext_grs_act_add_edge_to_keep(pattern, "e93_1348", ext_grs_NO_EDGE_POS, n_Arg_0_1205, n_MultipleAdd5693_1218, 73, e_e93);
+       ext_grs_edge_t *e_e92_1349 = ext_grs_act_add_edge_to_keep(pattern, "e92_1349", ext_grs_NO_EDGE_POS, n_Const944_1240, n_MultipleAdd5693_1218, 75, e_e92);
+       ext_grs_edge_t *e_pos1_125_1350 = ext_grs_act_add_edge_to_keep(pattern, "pos1_125_1350", 0, n_Load859_1239, n_Proj860_1241, 74, e_pos1_125);
+       ext_grs_edge_t *e_pos2_161_1351 = ext_grs_act_add_edge_to_keep(pattern, "pos2_161_1351", 1, n_MultipleAdd5691_1221, n_Load964_1256, 76, e_pos2_161);
+       ext_grs_edge_t *e_pos2_167_1352 = ext_grs_act_add_edge(pattern, "pos2_167_1352", 1, n_Bad82, n_Vector_op, 103);
+       ext_grs_edge_t *e_pos2_85_1353 = ext_grs_act_add_edge_to_keep(pattern, "pos2_85_1353", 1, n_MultipleAdd5709_1230, n_Load829_1201, 78, e_pos2_85);
+       ext_grs_edge_t *e_pos1_113_1354 = ext_grs_act_add_edge_to_keep(pattern, "pos1_113_1354", 0, n_Load844_1207, n_Proj845_1227, 79, e_pos1_113);
+       ext_grs_edge_t *e_pos1_114_1355 = ext_grs_act_add_edge_to_keep(pattern, "pos1_114_1355", 0, n_Load769_1264, n_Proj770_1262, 80, e_pos1_114);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33557);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33560);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33563);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33566);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33569);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33572);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33575);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33578);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33581);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33584);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33587);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33590);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33593);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33596);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33599);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33602);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33605);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_33608);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vload_16b_variant0 */
+
+
+/* functions for evaluation of conditions of action vload_16b_variant1 */
+static int grs_cond_func_34420(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[54/* Const944 */])) == 14;
+}
+static int grs_cond_func_34423(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[9/* Const727 */])) == 0;
+}
+static int grs_cond_func_34426(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[57/* MultipleAdd5701 */]) == 3;
+}
+static int grs_cond_func_34429(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[60/* Vector_Result0_Proj741 */]) == 3;
+}
+static int grs_cond_func_34432(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[62/* Proj815 */]) == 0;
+}
+static int grs_cond_func_34435(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[42/* Vector_Result11_Proj906 */]) == 3;
+}
+static int grs_cond_func_34438(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[8/* Proj740 */]) == 0;
+}
+static int grs_cond_func_34441(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[12/* MultipleAdd5717 */]) == 3;
+}
+static int grs_cond_func_34444(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[33/* MultipleAdd5693 */]) == 3;
+}
+static int grs_cond_func_34447(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[1/* Const959 */])) == 15;
+}
+static int grs_cond_func_34450(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[7/* Proj935 */]) == 0;
+}
+static int grs_cond_func_34453(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[37/* Vector_Result8_Proj861 */]) == 3;
+}
+static int grs_cond_func_34456(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[59/* MultipleAdd5703 */]) == 3;
+}
+static int grs_cond_func_34459(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[22/* Const824 */])) == 6;
+}
+static int grs_cond_func_34462(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[76/* Proj830 */]) == 0;
+}
+static int grs_cond_func_34465(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[63/* Proj755 */]) == 0;
+}
+static int grs_cond_func_34468(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[74/* Vector_Result2_Proj771 */]) == 3;
+}
+static int grs_cond_func_34471(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[10/* MultipleAdd5719 */]) == 3;
+}
+static int grs_cond_func_34474(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[30/* Vector_Result13_Proj936 */]) == 3;
+}
+static int grs_cond_func_34477(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[43/* MultipleAdd5695 */]) == 3;
+}
+static int grs_cond_func_34480(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[44/* Proj950 */]) == 0;
+}
+static int grs_cond_func_34483(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[27/* Const899 */])) == 11;
+}
+static int grs_cond_func_34486(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[58/* MultipleAdd5705 */]) == 3;
+}
+static int grs_cond_func_34489(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[45/* Proj845 */]) == 0;
+}
+static int grs_cond_func_34492(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[77/* Proj770 */]) == 0;
+}
+static int grs_cond_func_34495(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[20/* Const854 */])) == 8;
+}
+static int grs_cond_func_34498(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[38/* MultipleAdd5697 */]) == 3;
+}
+static int grs_cond_func_34501(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[5/* MultipleAdd5723 */]) == 3;
+}
+static int grs_cond_func_34504(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[61/* Vector_Result4_Proj801 */]) == 3;
+}
+static int grs_cond_func_34507(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[78/* Proj965 */]) == 0;
+}
+static int grs_cond_func_34510(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[46/* Vector_Result5_Proj816 */]) == 3;
+}
+static int grs_cond_func_34513(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[0/* Const764 */])) == 2;
+}
+static int grs_cond_func_34516(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[39/* MultipleAdd5707 */]) == 3;
+}
+static int grs_cond_func_34519(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[14/* Const929 */])) == 13;
+}
+static int grs_cond_func_34522(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[55/* Proj860 */]) == 0;
+}
+static int grs_cond_func_34525(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[35/* Proj785 */]) == 0;
+}
+static int grs_cond_func_34528(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[72/* Vector_Result10_Proj891 */]) == 3;
+}
+static int grs_cond_func_34531(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[50/* MultipleAdd5699 */]) == 3;
+}
+static int grs_cond_func_34534(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[41/* MultipleAdd5709 */]) == 3;
+}
+static int grs_cond_func_34537(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[16/* Vector_Result7_Proj846 */]) == 3;
+}
+static int grs_cond_func_34540(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[51/* Const794 */])) == 4;
+}
+static int grs_cond_func_34543(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj875 */]) == 0;
+}
+static int grs_cond_func_34546(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[29/* Proj800 */]) == 0;
+}
+static int grs_cond_func_34549(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[67/* Const809 */])) == 5;
+}
+static int grs_cond_func_34552(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[3/* Vector_Result1_Proj756 */]) == 3;
+}
+static int grs_cond_func_34555(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[4/* Vector_Result12_Proj921 */]) == 3;
+}
+static int grs_cond_func_34558(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[75/* Const731 */])) == 10;
+}
+static int grs_cond_func_34561(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[31/* MultipleAdd5711 */]) == 3;
+}
+static int grs_cond_func_34564(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[23/* Proj890 */]) == 0;
+}
+static int grs_cond_func_34567(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[25/* Vector_Result9_Proj876 */]) == 3;
+}
+static int grs_cond_func_34570(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[82/* Const839 */])) == 7;
+}
+static int grs_cond_func_34573(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[65/* Vector_Result3_Proj786 */]) == 3;
+}
+static int grs_cond_func_34576(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[24/* MultipleAdd5713 */]) == 3;
+}
+static int grs_cond_func_34579(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[73/* Const735 */])) == 1;
+}
+static int grs_cond_func_34582(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[52/* Const914 */])) == 12;
+}
+static int grs_cond_func_34585(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[49/* Proj905 */]) == 0;
+}
+static int grs_cond_func_34588(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[6/* Vector_Result14_Proj951 */]) == 3;
+}
+static int grs_cond_func_34591(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[80/* Vector_Result15_Proj966 */]) == 3;
+}
+static int grs_cond_func_34594(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[18/* Const869 */])) == 9;
+}
+static int grs_cond_func_34597(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[26/* MultipleAdd5715 */]) == 3;
+}
+static int grs_cond_func_34600(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[34/* MultipleAdd5691 */]) == 3;
+}
+static int grs_cond_func_34603(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[40/* Vector_Result6_Proj831 */]) == 3;
+}
+static int grs_cond_func_34606(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[81/* Proj920 */]) == 0;
+}
+static int grs_cond_func_34609(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[68/* Const779 */])) == 3;
+}
+
+static void *grs_eval_out_func_34996(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[94/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_34999(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[95/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_35002(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[98/* VProj83 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_35005(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[91/* VProj85 */], 11);
+  return(NULL);
+}
+static void *grs_eval_out_func_35008(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[89/* VProj87 */], 8);
+  return(NULL);
+}
+static void *grs_eval_out_func_35011(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[101/* VProj89 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_35014(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[88/* VProj91 */], 13);
+  return(NULL);
+}
+static void *grs_eval_out_func_35017(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[96/* VProj93 */], 4);
+  return(NULL);
+}
+static void *grs_eval_out_func_35020(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[92/* VProj95 */], 5);
+  return(NULL);
+}
+static void *grs_eval_out_func_35023(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[100/* VProj97 */], 10);
+  return(NULL);
+}
+static void *grs_eval_out_func_35026(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[86/* VProj99 */], 7);
+  return(NULL);
+}
+static void *grs_eval_out_func_35029(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[83/* VProj101 */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_35032(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[84/* VProj103 */], 12);
+  return(NULL);
+}
+static void *grs_eval_out_func_35035(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[87/* VProj105 */], 9);
+  return(NULL);
+}
+static void *grs_eval_out_func_35038(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[99/* VProj107 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_35041(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[85/* VProj109 */], 14);
+  return(NULL);
+}
+static void *grs_eval_out_func_35044(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[102/* VProj111 */], 15);
+  return(NULL);
+}
+static void *grs_eval_out_func_35047(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[90/* VProj113 */], 6);
+  return(NULL);
+}
+/* functions for building the pattern of action vload_16b_variant1 */
+static _inline ext_grs_action_t *grs_action_vload_16b_variant1_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vload_16b_variant1");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Const764 = ext_grs_act_add_node(pattern, "Const764", grs_op_Const, mode_Is, 0);
+    ext_grs_node_t *n_Const959 = ext_grs_act_add_node(pattern, "Const959", grs_op_Const, mode_Is, 1);
+    ext_grs_node_t *n_Load874 = ext_grs_act_add_node(pattern, "Load874", grs_op_Load, mode_T, 2);
+    ext_grs_node_t *n_Vector_Result1_Proj756 = ext_grs_act_add_node(pattern, "Vector_Result1_Proj756", grs_op_Proj, mode_Bu, 3);
+    ext_grs_node_t *n_Vector_Result12_Proj921 = ext_grs_act_add_node(pattern, "Vector_Result12_Proj921", grs_op_Proj, mode_Bu, 4);
+    ext_grs_node_t *n_MultipleAdd5723 = ext_grs_act_add_node(pattern, "MultipleAdd5723", grs_op_MultipleAdd, mode_P, 5);
+    ext_grs_node_t *n_Vector_Result14_Proj951 = ext_grs_act_add_node(pattern, "Vector_Result14_Proj951", grs_op_Proj, mode_Bu, 6);
+    ext_grs_node_t *n_Proj935 = ext_grs_act_add_node(pattern, "Proj935", grs_op_Proj, mode_M, 7);
+    ext_grs_node_t *n_Proj740 = ext_grs_act_add_node(pattern, "Proj740", grs_op_Proj, mode_M, 8);
+    ext_grs_node_t *n_Const727 = ext_grs_act_add_node(pattern, "Const727", grs_op_Const, mode_Is, 9);
+    ext_grs_node_t *n_MultipleAdd5719 = ext_grs_act_add_node(pattern, "MultipleAdd5719", grs_op_MultipleAdd, mode_P, 10);
+    ext_grs_node_t *n_Load934 = ext_grs_act_add_node(pattern, "Load934", grs_op_Load, mode_T, 11);
+    ext_grs_node_t *n_MultipleAdd5717 = ext_grs_act_add_node(pattern, "MultipleAdd5717", grs_op_MultipleAdd, mode_P, 12);
+    ext_grs_node_t *n_Load739 = ext_grs_act_add_node(pattern, "Load739", grs_op_Load, mode_T, 13);
+    ext_grs_node_t *n_Const929 = ext_grs_act_add_node(pattern, "Const929", grs_op_Const, mode_Is, 14);
+    ext_grs_node_t *n_Load829 = ext_grs_act_add_node(pattern, "Load829", grs_op_Load, mode_T, 15);
+    ext_grs_node_t *n_Vector_Result7_Proj846 = ext_grs_act_add_node(pattern, "Vector_Result7_Proj846", grs_op_Proj, mode_Bu, 16);
+    ext_grs_node_t *n_Proj875 = ext_grs_act_add_node(pattern, "Proj875", grs_op_Proj, mode_M, 17);
+    ext_grs_node_t *n_Const869 = ext_grs_act_add_node(pattern, "Const869", grs_op_Const, mode_Is, 18);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 19);
+    ext_grs_node_t *n_Const854 = ext_grs_act_add_node(pattern, "Const854", grs_op_Const, mode_Is, 20);
+    ext_grs_node_t *n_Load844 = ext_grs_act_add_node(pattern, "Load844", grs_op_Load, mode_T, 21);
+    ext_grs_node_t *n_Const824 = ext_grs_act_add_node(pattern, "Const824", grs_op_Const, mode_Is, 22);
+    ext_grs_node_t *n_Proj890 = ext_grs_act_add_node(pattern, "Proj890", grs_op_Proj, mode_M, 23);
+    ext_grs_node_t *n_MultipleAdd5713 = ext_grs_act_add_node(pattern, "MultipleAdd5713", grs_op_MultipleAdd, mode_P, 24);
+    ext_grs_node_t *n_Vector_Result9_Proj876 = ext_grs_act_add_node(pattern, "Vector_Result9_Proj876", grs_op_Proj, mode_Bu, 25);
+    ext_grs_node_t *n_MultipleAdd5715 = ext_grs_act_add_node(pattern, "MultipleAdd5715", grs_op_MultipleAdd, mode_P, 26);
+    ext_grs_node_t *n_Const899 = ext_grs_act_add_node(pattern, "Const899", grs_op_Const, mode_Is, 27);
+    ext_grs_node_t *n_Load889 = ext_grs_act_add_node(pattern, "Load889", grs_op_Load, mode_T, 28);
+    ext_grs_node_t *n_Proj800 = ext_grs_act_add_node(pattern, "Proj800", grs_op_Proj, mode_M, 29);
+    ext_grs_node_t *n_Vector_Result13_Proj936 = ext_grs_act_add_node(pattern, "Vector_Result13_Proj936", grs_op_Proj, mode_Bu, 30);
+    ext_grs_node_t *n_MultipleAdd5711 = ext_grs_act_add_node(pattern, "MultipleAdd5711", grs_op_MultipleAdd, mode_P, 31);
+    ext_grs_node_t *n_Load949 = ext_grs_act_add_node(pattern, "Load949", grs_op_Load, mode_T, 32);
+    ext_grs_node_t *n_MultipleAdd5693 = ext_grs_act_add_node(pattern, "MultipleAdd5693", grs_op_MultipleAdd, mode_P, 33);
+    ext_grs_node_t *n_MultipleAdd5691 = ext_grs_act_add_node(pattern, "MultipleAdd5691", grs_op_MultipleAdd, mode_P, 34);
+    ext_grs_node_t *n_Proj785 = ext_grs_act_add_node(pattern, "Proj785", grs_op_Proj, mode_M, 35);
+    ext_grs_node_t *n_Load799 = ext_grs_act_add_node(pattern, "Load799", grs_op_Load, mode_T, 36);
+    ext_grs_node_t *n_Vector_Result8_Proj861 = ext_grs_act_add_node(pattern, "Vector_Result8_Proj861", grs_op_Proj, mode_Bu, 37);
+    ext_grs_node_t *n_MultipleAdd5697 = ext_grs_act_add_node(pattern, "MultipleAdd5697", grs_op_MultipleAdd, mode_P, 38);
+    ext_grs_node_t *n_MultipleAdd5707 = ext_grs_act_add_node(pattern, "MultipleAdd5707", grs_op_MultipleAdd, mode_P, 39);
+    ext_grs_node_t *n_Vector_Result6_Proj831 = ext_grs_act_add_node(pattern, "Vector_Result6_Proj831", grs_op_Proj, mode_Bu, 40);
+    ext_grs_node_t *n_MultipleAdd5709 = ext_grs_act_add_node(pattern, "MultipleAdd5709", grs_op_MultipleAdd, mode_P, 41);
+    ext_grs_node_t *n_Vector_Result11_Proj906 = ext_grs_act_add_node(pattern, "Vector_Result11_Proj906", grs_op_Proj, mode_Bu, 42);
+    ext_grs_node_t *n_MultipleAdd5695 = ext_grs_act_add_node(pattern, "MultipleAdd5695", grs_op_MultipleAdd, mode_P, 43);
+    ext_grs_node_t *n_Proj950 = ext_grs_act_add_node(pattern, "Proj950", grs_op_Proj, mode_M, 44);
+    ext_grs_node_t *n_Proj845 = ext_grs_act_add_node(pattern, "Proj845", grs_op_Proj, mode_M, 45);
+    ext_grs_node_t *n_Vector_Result5_Proj816 = ext_grs_act_add_node(pattern, "Vector_Result5_Proj816", grs_op_Proj, mode_Bu, 46);
+    ext_grs_node_t *n_Load904 = ext_grs_act_add_node(pattern, "Load904", grs_op_Load, mode_T, 47);
+    ext_grs_node_t *n_Load784 = ext_grs_act_add_node(pattern, "Load784", grs_op_Load, mode_T, 48);
+    ext_grs_node_t *n_Proj905 = ext_grs_act_add_node(pattern, "Proj905", grs_op_Proj, mode_M, 49);
+    ext_grs_node_t *n_MultipleAdd5699 = ext_grs_act_add_node(pattern, "MultipleAdd5699", grs_op_MultipleAdd, mode_P, 50);
+    ext_grs_node_t *n_Const794 = ext_grs_act_add_node(pattern, "Const794", grs_op_Const, mode_Is, 51);
+    ext_grs_node_t *n_Const914 = ext_grs_act_add_node(pattern, "Const914", grs_op_Const, mode_Is, 52);
+    ext_grs_node_t *n_Load859 = ext_grs_act_add_node(pattern, "Load859", grs_op_Load, mode_T, 53);
+    ext_grs_node_t *n_Const944 = ext_grs_act_add_node(pattern, "Const944", grs_op_Const, mode_Is, 54);
+    ext_grs_node_t *n_Proj860 = ext_grs_act_add_node(pattern, "Proj860", grs_op_Proj, mode_M, 55);
+    ext_grs_node_t *n_IR_node5724 = ext_grs_act_add_node(pattern, "IR_node5724", grs_op_IR_node, mode_ANY, 56);
+    ext_grs_node_t *n_MultipleAdd5701 = ext_grs_act_add_node(pattern, "MultipleAdd5701", grs_op_MultipleAdd, mode_P, 57);
+    ext_grs_node_t *n_MultipleAdd5705 = ext_grs_act_add_node(pattern, "MultipleAdd5705", grs_op_MultipleAdd, mode_P, 58);
+    ext_grs_node_t *n_MultipleAdd5703 = ext_grs_act_add_node(pattern, "MultipleAdd5703", grs_op_MultipleAdd, mode_P, 59);
+    ext_grs_node_t *n_Vector_Result0_Proj741 = ext_grs_act_add_node(pattern, "Vector_Result0_Proj741", grs_op_Proj, mode_Bu, 60);
+    ext_grs_node_t *n_Vector_Result4_Proj801 = ext_grs_act_add_node(pattern, "Vector_Result4_Proj801", grs_op_Proj, mode_Bu, 61);
+    ext_grs_node_t *n_Proj815 = ext_grs_act_add_node(pattern, "Proj815", grs_op_Proj, mode_M, 62);
+    ext_grs_node_t *n_Proj755 = ext_grs_act_add_node(pattern, "Proj755", grs_op_Proj, mode_M, 63);
+    ext_grs_node_t *n_Load814 = ext_grs_act_add_node(pattern, "Load814", grs_op_Load, mode_T, 64);
+    ext_grs_node_t *n_Vector_Result3_Proj786 = ext_grs_act_add_node(pattern, "Vector_Result3_Proj786", grs_op_Proj, mode_Bu, 65);
+    ext_grs_node_t *n_Load754 = ext_grs_act_add_node(pattern, "Load754", grs_op_Load, mode_T, 66);
+    ext_grs_node_t *n_Const809 = ext_grs_act_add_node(pattern, "Const809", grs_op_Const, mode_Is, 67);
+    ext_grs_node_t *n_Const779 = ext_grs_act_add_node(pattern, "Const779", grs_op_Const, mode_Is, 68);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 69);
+    ext_grs_node_t *n_Load964 = ext_grs_act_add_node(pattern, "Load964", grs_op_Load, mode_T, 70);
+    ext_grs_node_t *n_Load919 = ext_grs_act_add_node(pattern, "Load919", grs_op_Load, mode_T, 71);
+    ext_grs_node_t *n_Vector_Result10_Proj891 = ext_grs_act_add_node(pattern, "Vector_Result10_Proj891", grs_op_Proj, mode_Bu, 72);
+    ext_grs_node_t *n_Const735 = ext_grs_act_add_node(pattern, "Const735", grs_op_Const, mode_Is, 73);
+    ext_grs_node_t *n_Vector_Result2_Proj771 = ext_grs_act_add_node(pattern, "Vector_Result2_Proj771", grs_op_Proj, mode_Bu, 74);
+    ext_grs_node_t *n_Const731 = ext_grs_act_add_node(pattern, "Const731", grs_op_Const, mode_Is, 75);
+    ext_grs_node_t *n_Proj830 = ext_grs_act_add_node(pattern, "Proj830", grs_op_Proj, mode_M, 76);
+    ext_grs_node_t *n_Proj770 = ext_grs_act_add_node(pattern, "Proj770", grs_op_Proj, mode_M, 77);
+    ext_grs_node_t *n_Proj965 = ext_grs_act_add_node(pattern, "Proj965", grs_op_Proj, mode_M, 78);
+    ext_grs_node_t *n_Load769 = ext_grs_act_add_node(pattern, "Load769", grs_op_Load, mode_T, 79);
+    ext_grs_node_t *n_Vector_Result15_Proj966 = ext_grs_act_add_node(pattern, "Vector_Result15_Proj966", grs_op_Proj, mode_Bu, 80);
+    ext_grs_node_t *n_Proj920 = ext_grs_act_add_node(pattern, "Proj920", grs_op_Proj, mode_M, 81);
+    ext_grs_node_t *n_Const839 = ext_grs_act_add_node(pattern, "Const839", grs_op_Const, mode_Is, 82);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_144 = ext_grs_act_add_edge(pattern, "pos1_144", 0, n_Load844, n_Vector_Result7_Proj846, 0);
+    ext_grs_edge_t *e_pos1_149 = ext_grs_act_add_edge(pattern, "pos1_149", 0, n_Load799, n_Proj800, 1);
+    ext_grs_edge_t *e_pos1_148 = ext_grs_act_add_edge(pattern, "pos1_148", 0, n_Load874, n_Proj875, 2);
+    ext_grs_edge_t *e_pos2_178 = ext_grs_act_add_edge(pattern, "pos2_178", 1, n_MultipleAdd5691, n_Load964, 3);
+    ext_grs_edge_t *e_e133 = ext_grs_act_add_edge(pattern, "e133", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5707, 4);
+    ext_grs_edge_t *e_e132 = ext_grs_act_add_edge(pattern, "e132", ext_grs_NO_EDGE_POS, n_Const839, n_MultipleAdd5707, 5);
+    ext_grs_edge_t *e_e134 = ext_grs_act_add_edge(pattern, "e134", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5707, 6);
+    ext_grs_edge_t *e_e83 = ext_grs_act_add_edge(pattern, "e83", ext_grs_NO_EDGE_POS, n_Const731, n_MultipleAdd5701, 7);
+    ext_grs_edge_t *e_pos1_136 = ext_grs_act_add_edge(pattern, "pos1_136", 0, n_Load859, n_Proj860, 8);
+    ext_grs_edge_t *e_pos1_138 = ext_grs_act_add_edge(pattern, "pos1_138", 0, n_Load784, n_Proj785, 9);
+    ext_grs_edge_t *e_pos1_139 = ext_grs_act_add_edge(pattern, "pos1_139", 0, n_Load889, n_Vector_Result10_Proj891, 10);
+    ext_grs_edge_t *e_pos1_130 = ext_grs_act_add_edge(pattern, "pos1_130", 0, n_Load964, n_Proj965, 11);
+    ext_grs_edge_t *e_e85 = ext_grs_act_add_edge(pattern, "e85", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5701, 12);
+    ext_grs_edge_t *e_pos1_131 = ext_grs_act_add_edge(pattern, "pos1_131", 0, n_Load814, n_Vector_Result5_Proj816, 13);
+    ext_grs_edge_t *e_e84 = ext_grs_act_add_edge(pattern, "e84", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5701, 14);
+    ext_grs_edge_t *e_e120 = ext_grs_act_add_edge(pattern, "e120", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5705, 15);
+    ext_grs_edge_t *e_e124 = ext_grs_act_add_edge(pattern, "e124", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5697, 16);
+    ext_grs_edge_t *e_e123 = ext_grs_act_add_edge(pattern, "e123", ext_grs_NO_EDGE_POS, n_Const914, n_MultipleAdd5697, 17);
+    ext_grs_edge_t *e_pos1_89 = ext_grs_act_add_edge(pattern, "pos1_89", 0, n_Load814, n_Proj815, 18);
+    ext_grs_edge_t *e_pos1_88 = ext_grs_act_add_edge(pattern, "pos1_88", 0, n_Load904, n_Vector_Result11_Proj906, 19);
+    ext_grs_edge_t *e_e128 = ext_grs_act_add_edge(pattern, "e128", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5723, 20);
+    ext_grs_edge_t *e_pos2_107 = ext_grs_act_add_edge(pattern, "pos2_107", 1, n_MultipleAdd5705, n_Load859, 21);
+    ext_grs_edge_t *e_pos1_86 = ext_grs_act_add_edge(pattern, "pos1_86", 0, n_Load739, n_Vector_Result0_Proj741, 22);
+    ext_grs_edge_t *e_e127 = ext_grs_act_add_edge(pattern, "e127", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5723, 23);
+    ext_grs_edge_t *e_e126 = ext_grs_act_add_edge(pattern, "e126", ext_grs_NO_EDGE_POS, n_Const727, n_MultipleAdd5723, 24);
+    ext_grs_edge_t *e_e125 = ext_grs_act_add_edge(pattern, "e125", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5697, 25);
+    ext_grs_edge_t *e_pos2_117 = ext_grs_act_add_edge(pattern, "pos2_117", 1, n_MultipleAdd5695, n_Load934, 26);
+    ext_grs_edge_t *e_pos2_116 = ext_grs_act_add_edge(pattern, "pos2_116", 1, n_MultipleAdd5717, n_Load769, 27);
+    ext_grs_edge_t *e_pos1_168 = ext_grs_act_add_edge(pattern, "pos1_168", 0, n_Load964, n_Vector_Result15_Proj966, 28);
+    ext_grs_edge_t *e_pos1_167 = ext_grs_act_add_edge(pattern, "pos1_167", 0, n_Load949, n_Vector_Result14_Proj951, 29);
+    ext_grs_edge_t *e_pos1_165 = ext_grs_act_add_edge(pattern, "pos1_165", 0, n_Load904, n_Proj905, 30);
+    ext_grs_edge_t *e_pos1_160 = ext_grs_act_add_edge(pattern, "pos1_160", 0, n_Load784, n_Vector_Result3_Proj786, 31);
+    ext_grs_edge_t *e_e111 = ext_grs_act_add_edge(pattern, "e111", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5719, 32);
+    ext_grs_edge_t *e_e110 = ext_grs_act_add_edge(pattern, "e110", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5719, 33);
+    ext_grs_edge_t *e_e113 = ext_grs_act_add_edge(pattern, "e113", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5695, 34);
+    ext_grs_edge_t *e_e112 = ext_grs_act_add_edge(pattern, "e112", ext_grs_NO_EDGE_POS, n_Const929, n_MultipleAdd5695, 35);
+    ext_grs_edge_t *e_e119 = ext_grs_act_add_edge(pattern, "e119", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5705, 36);
+    ext_grs_edge_t *e_e118 = ext_grs_act_add_edge(pattern, "e118", ext_grs_NO_EDGE_POS, n_Const854, n_MultipleAdd5705, 37);
+    ext_grs_edge_t *e_e114 = ext_grs_act_add_edge(pattern, "e114", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5695, 38);
+    ext_grs_edge_t *e_pos1_159 = ext_grs_act_add_edge(pattern, "pos1_159", 0, n_Load874, n_Vector_Result9_Proj876, 39);
+    ext_grs_edge_t *e_pos1_158 = ext_grs_act_add_edge(pattern, "pos1_158", 0, n_Load889, n_Proj890, 40);
+    ext_grs_edge_t *e_pos1_152 = ext_grs_act_add_edge(pattern, "pos1_152", 0, n_Load919, n_Vector_Result12_Proj921, 41);
+    ext_grs_edge_t *e_pos1_150 = ext_grs_act_add_edge(pattern, "pos1_150", 0, n_Load754, n_Vector_Result1_Proj756, 42);
+    ext_grs_edge_t *e_e102 = ext_grs_act_add_edge(pattern, "e102", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5703, 43);
+    ext_grs_edge_t *e_e101 = ext_grs_act_add_edge(pattern, "e101", ext_grs_NO_EDGE_POS, n_Const869, n_MultipleAdd5703, 44);
+    ext_grs_edge_t *e_e109 = ext_grs_act_add_edge(pattern, "e109", ext_grs_NO_EDGE_POS, n_Const735, n_MultipleAdd5719, 45);
+    ext_grs_edge_t *e_e103 = ext_grs_act_add_edge(pattern, "e103", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5703, 46);
+    ext_grs_edge_t *e_e140 = ext_grs_act_add_edge(pattern, "e140", ext_grs_NO_EDGE_POS, n_Const899, n_MultipleAdd5699, 47);
+    ext_grs_edge_t *e_pos1_108 = ext_grs_act_add_edge(pattern, "pos1_108", 0, n_Load934, n_Vector_Result13_Proj936, 48);
+    ext_grs_edge_t *e_e141 = ext_grs_act_add_edge(pattern, "e141", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5699, 49);
+    ext_grs_edge_t *e_e142 = ext_grs_act_add_edge(pattern, "e142", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5699, 50);
+    ext_grs_edge_t *e_e145 = ext_grs_act_add_edge(pattern, "e145", ext_grs_NO_EDGE_POS, n_Const824, n_MultipleAdd5709, 51);
+    ext_grs_edge_t *e_e146 = ext_grs_act_add_edge(pattern, "e146", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5709, 52);
+    ext_grs_edge_t *e_e147 = ext_grs_act_add_edge(pattern, "e147", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5709, 53);
+    ext_grs_edge_t *e_pos2_135 = ext_grs_act_add_edge(pattern, "pos2_135", 1, n_MultipleAdd5713, n_Load799, 54);
+    ext_grs_edge_t *e_pos2_137 = ext_grs_act_add_edge(pattern, "pos2_137", 1, n_MultipleAdd5711, n_Load814, 55);
+    ext_grs_edge_t *e_pos1_100 = ext_grs_act_add_edge(pattern, "pos1_100", 0, n_Load859, n_Vector_Result8_Proj861, 56);
+    ext_grs_edge_t *e_pos1_104 = ext_grs_act_add_edge(pattern, "pos1_104", 0, n_Load829, n_Proj830, 57);
+    ext_grs_edge_t *e_pos1_105 = ext_grs_act_add_edge(pattern, "pos1_105", 0, n_Load754, n_Proj755, 58);
+    ext_grs_edge_t *e_pos0_177 = ext_grs_act_add_edge(pattern, "pos0_177", -1, n_Vector_op_Block, n_Load964, 59);
+    ext_grs_edge_t *e_pos1_106 = ext_grs_act_add_edge(pattern, "pos1_106", 0, n_Load769, n_Vector_Result2_Proj771, 60);
+    ext_grs_edge_t *e_e156 = ext_grs_act_add_edge(pattern, "e156", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5711, 61);
+    ext_grs_edge_t *e_e154 = ext_grs_act_add_edge(pattern, "e154", ext_grs_NO_EDGE_POS, n_Const809, n_MultipleAdd5711, 62);
+    ext_grs_edge_t *e_pos1_176 = ext_grs_act_add_edge(pattern, "pos1_176", 0, n_Load829, n_Vector_Result6_Proj831, 63);
+    ext_grs_edge_t *e_e155 = ext_grs_act_add_edge(pattern, "e155", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5711, 64);
+    ext_grs_edge_t *e_pos2_143 = ext_grs_act_add_edge(pattern, "pos2_143", 1, n_MultipleAdd5701, n_Load889, 65);
+    ext_grs_edge_t *e_pos1_179 = ext_grs_act_add_edge(pattern, "pos1_179", 0, n_Load919, n_Proj920, 66);
+    ext_grs_edge_t *e_pos2_153 = ext_grs_act_add_edge(pattern, "pos2_153", 1, n_MultipleAdd5719, n_Load754, 67);
+    ext_grs_edge_t *e_pos2_151 = ext_grs_act_add_edge(pattern, "pos2_151", 1, n_MultipleAdd5707, n_Load844, 68);
+    ext_grs_edge_t *e_e162 = ext_grs_act_add_edge(pattern, "e162", ext_grs_NO_EDGE_POS, n_Const794, n_MultipleAdd5713, 69);
+    ext_grs_edge_t *e_e163 = ext_grs_act_add_edge(pattern, "e163", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5713, 70);
+    ext_grs_edge_t *e_e164 = ext_grs_act_add_edge(pattern, "e164", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5713, 71);
+    ext_grs_edge_t *e_pos2_157 = ext_grs_act_add_edge(pattern, "pos2_157", 1, n_MultipleAdd5697, n_Load919, 72);
+    ext_grs_edge_t *e_e97 = ext_grs_act_add_edge(pattern, "e97", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5693, 73);
+    ext_grs_edge_t *e_pos1_90 = ext_grs_act_add_edge(pattern, "pos1_90", 0, n_Load739, n_Proj740, 74);
+    ext_grs_edge_t *e_e95 = ext_grs_act_add_edge(pattern, "e95", ext_grs_NO_EDGE_POS, n_Const944, n_MultipleAdd5693, 75);
+    ext_grs_edge_t *e_pos1_121 = ext_grs_act_add_edge(pattern, "pos1_121", 0, n_Load844, n_Proj845, 76);
+    ext_grs_edge_t *e_e96 = ext_grs_act_add_edge(pattern, "e96", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5693, 77);
+    ext_grs_edge_t *e_pos2_94 = ext_grs_act_add_edge(pattern, "pos2_94", 1, n_MultipleAdd5723, n_Load739, 78);
+    ext_grs_edge_t *e_pos1_98 = ext_grs_act_add_edge(pattern, "pos1_98", 0, n_Load934, n_Proj935, 79);
+    ext_grs_edge_t *e_e171 = ext_grs_act_add_edge(pattern, "e171", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5715, 80);
+    ext_grs_edge_t *e_e170 = ext_grs_act_add_edge(pattern, "e170", ext_grs_NO_EDGE_POS, n_Const779, n_MultipleAdd5715, 81);
+    ext_grs_edge_t *e_pos1_129 = ext_grs_act_add_edge(pattern, "pos1_129", 0, n_Load799, n_Vector_Result4_Proj801, 82);
+    ext_grs_edge_t *e_pos1_122 = ext_grs_act_add_edge(pattern, "pos1_122", 0, n_Load769, n_Proj770, 83);
+    ext_grs_edge_t *e_e93 = ext_grs_act_add_edge(pattern, "e93", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5717, 84);
+    ext_grs_edge_t *e_e91 = ext_grs_act_add_edge(pattern, "e91", ext_grs_NO_EDGE_POS, n_Const764, n_MultipleAdd5717, 85);
+    ext_grs_edge_t *e_pos2_99 = ext_grs_act_add_edge(pattern, "pos2_99", 1, n_MultipleAdd5699, n_Load904, 86);
+    ext_grs_edge_t *e_e92 = ext_grs_act_add_edge(pattern, "e92", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5717, 87);
+    ext_grs_edge_t *e_pos2_161 = ext_grs_act_add_edge(pattern, "pos2_161", 1, n_MultipleAdd5703, n_Load874, 88);
+    ext_grs_edge_t *e_e174 = ext_grs_act_add_edge(pattern, "e174", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5691, 89);
+    ext_grs_edge_t *e_e175 = ext_grs_act_add_edge(pattern, "e175", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5691, 90);
+    ext_grs_edge_t *e_e172 = ext_grs_act_add_edge(pattern, "e172", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5715, 91);
+    ext_grs_edge_t *e_e173 = ext_grs_act_add_edge(pattern, "e173", ext_grs_NO_EDGE_POS, n_Const959, n_MultipleAdd5691, 92);
+    ext_grs_edge_t *e_pos2_169 = ext_grs_act_add_edge(pattern, "pos2_169", 1, n_MultipleAdd5693, n_Load949, 93);
+    ext_grs_edge_t *e_pos2_166 = ext_grs_act_add_edge(pattern, "pos2_166", 1, n_MultipleAdd5715, n_Load784, 94);
+    ext_grs_edge_t *e_pos2_87 = ext_grs_act_add_edge(pattern, "pos2_87", 1, n_MultipleAdd5709, n_Load829, 95);
+    ext_grs_edge_t *e_pos1_115 = ext_grs_act_add_edge(pattern, "pos1_115", 0, n_Load949, n_Proj950, 96);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const944};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34420, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const727};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34423, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5701};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34426, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_Proj741};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34429, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj815};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34432, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result11_Proj906};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34435, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj740};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34438, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5717};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34441, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5693};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34444, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const959};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34447, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj935};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34450, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result8_Proj861};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34453, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5703};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34456, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const824};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34459, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj830};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34462, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj755};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34465, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result2_Proj771};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34468, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5719};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34471, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result13_Proj936};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34474, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5695};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34477, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj950};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34480, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const899};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34483, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5705};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34486, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj845};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34489, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj770};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34492, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const854};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34495, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5697};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34498, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5723};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34501, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result4_Proj801};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34504, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj965};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34507, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result5_Proj816};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34510, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const764};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34513, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5707};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34516, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const929};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34519, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj860};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34522, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj785};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34525, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result10_Proj891};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34528, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5699};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34531, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5709};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34534, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result7_Proj846};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34537, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const794};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34540, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj875};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34543, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj800};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34546, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const809};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34549, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result1_Proj756};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34552, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result12_Proj921};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34555, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const731};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34558, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5711};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34561, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj890};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34564, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result9_Proj876};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34567, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const839};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34570, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result3_Proj786};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34573, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5713};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34576, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const735};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34579, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const914};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34582, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj905};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34585, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result14_Proj951};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34588, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result15_Proj966};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34591, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const869};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34594, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5715};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34597, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5691};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34600, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result6_Proj831};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34603, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj920};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34606, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const779};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_34609, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Const764_1356 = ext_grs_act_add_node_to_keep(pattern, "Const764_1356", grs_op_Const, mode_Is, 0, n_Const764);
+       ext_grs_node_t *n_Const959_1357 = ext_grs_act_add_node_to_keep(pattern, "Const959_1357", grs_op_Const, mode_Is, 1, n_Const959);
+       ext_grs_node_t *n_Load874_1358 = ext_grs_act_add_node_to_keep(pattern, "Load874_1358", grs_op_Load, mode_T, 2, n_Load874);
+       ext_grs_node_t *n_VProj101_1359 = ext_grs_act_add_node_to_keep(pattern, "VProj101_1359", grs_op_VProj, mode_Bu, 83, n_Vector_Result1_Proj756);
+       ext_grs_node_t *n_VProj103_1360 = ext_grs_act_add_node_to_keep(pattern, "VProj103_1360", grs_op_VProj, mode_Bu, 84, n_Vector_Result12_Proj921);
+       ext_grs_node_t *n_MultipleAdd5723_1361 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5723_1361", grs_op_MultipleAdd, mode_P, 5, n_MultipleAdd5723);
+       ext_grs_node_t *n_VProj109_1362 = ext_grs_act_add_node_to_keep(pattern, "VProj109_1362", grs_op_VProj, mode_Bu, 85, n_Vector_Result14_Proj951);
+       ext_grs_node_t *n_Proj935_1363 = ext_grs_act_add_node_to_keep(pattern, "Proj935_1363", grs_op_Proj, mode_M, 7, n_Proj935);
+       ext_grs_node_t *n_Proj740_1364 = ext_grs_act_add_node_to_keep(pattern, "Proj740_1364", grs_op_Proj, mode_M, 8, n_Proj740);
+       ext_grs_node_t *n_Const727_1365 = ext_grs_act_add_node_to_keep(pattern, "Const727_1365", grs_op_Const, mode_Is, 9, n_Const727);
+       ext_grs_node_t *n_MultipleAdd5719_1366 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5719_1366", grs_op_MultipleAdd, mode_P, 10, n_MultipleAdd5719);
+       ext_grs_node_t *n_Load934_1367 = ext_grs_act_add_node_to_keep(pattern, "Load934_1367", grs_op_Load, mode_T, 11, n_Load934);
+       ext_grs_node_t *n_MultipleAdd5717_1368 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5717_1368", grs_op_MultipleAdd, mode_P, 12, n_MultipleAdd5717);
+       ext_grs_node_t *n_Load739_1369 = ext_grs_act_add_node_to_keep(pattern, "Load739_1369", grs_op_Load, mode_T, 13, n_Load739);
+       ext_grs_node_t *n_Const929_1370 = ext_grs_act_add_node_to_keep(pattern, "Const929_1370", grs_op_Const, mode_Is, 14, n_Const929);
+       ext_grs_node_t *n_Load829_1371 = ext_grs_act_add_node_to_keep(pattern, "Load829_1371", grs_op_Load, mode_T, 15, n_Load829);
+       ext_grs_node_t *n_VProj99_1372 = ext_grs_act_add_node_to_keep(pattern, "VProj99_1372", grs_op_VProj, mode_Bu, 86, n_Vector_Result7_Proj846);
+       ext_grs_node_t *n_Proj875_1373 = ext_grs_act_add_node_to_keep(pattern, "Proj875_1373", grs_op_Proj, mode_M, 17, n_Proj875);
+       ext_grs_node_t *n_Const869_1374 = ext_grs_act_add_node_to_keep(pattern, "Const869_1374", grs_op_Const, mode_Is, 18, n_Const869);
+       ext_grs_node_t *n_Arg_0_1375 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1375", grs_op_VectorBase, mode_ANY, 19, n_Arg_0);
+       ext_grs_node_t *n_Const854_1376 = ext_grs_act_add_node_to_keep(pattern, "Const854_1376", grs_op_Const, mode_Is, 20, n_Const854);
+       ext_grs_node_t *n_Load844_1377 = ext_grs_act_add_node_to_keep(pattern, "Load844_1377", grs_op_Load, mode_T, 21, n_Load844);
+       ext_grs_node_t *n_Const824_1378 = ext_grs_act_add_node_to_keep(pattern, "Const824_1378", grs_op_Const, mode_Is, 22, n_Const824);
+       ext_grs_node_t *n_Proj890_1379 = ext_grs_act_add_node_to_keep(pattern, "Proj890_1379", grs_op_Proj, mode_M, 23, n_Proj890);
+       ext_grs_node_t *n_VProj105_1380 = ext_grs_act_add_node_to_keep(pattern, "VProj105_1380", grs_op_VProj, mode_Bu, 87, n_Vector_Result9_Proj876);
+       ext_grs_node_t *n_MultipleAdd5713_1381 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5713_1381", grs_op_MultipleAdd, mode_P, 24, n_MultipleAdd5713);
+       ext_grs_node_t *n_MultipleAdd5715_1382 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5715_1382", grs_op_MultipleAdd, mode_P, 26, n_MultipleAdd5715);
+       ext_grs_node_t *n_Const899_1383 = ext_grs_act_add_node_to_keep(pattern, "Const899_1383", grs_op_Const, mode_Is, 27, n_Const899);
+       ext_grs_node_t *n_Load889_1384 = ext_grs_act_add_node_to_keep(pattern, "Load889_1384", grs_op_Load, mode_T, 28, n_Load889);
+       ext_grs_node_t *n_Proj800_1385 = ext_grs_act_add_node_to_keep(pattern, "Proj800_1385", grs_op_Proj, mode_M, 29, n_Proj800);
+       ext_grs_node_t *n_VProj91_1386 = ext_grs_act_add_node_to_keep(pattern, "VProj91_1386", grs_op_VProj, mode_Bu, 88, n_Vector_Result13_Proj936);
+       ext_grs_node_t *n_MultipleAdd5711_1387 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5711_1387", grs_op_MultipleAdd, mode_P, 31, n_MultipleAdd5711);
+       ext_grs_node_t *n_MultipleAdd5693_1388 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5693_1388", grs_op_MultipleAdd, mode_P, 33, n_MultipleAdd5693);
+       ext_grs_node_t *n_Load949_1389 = ext_grs_act_add_node_to_keep(pattern, "Load949_1389", grs_op_Load, mode_T, 32, n_Load949);
+       ext_grs_node_t *n_Proj785_1390 = ext_grs_act_add_node_to_keep(pattern, "Proj785_1390", grs_op_Proj, mode_M, 35, n_Proj785);
+       ext_grs_node_t *n_MultipleAdd5691_1391 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5691_1391", grs_op_MultipleAdd, mode_P, 34, n_MultipleAdd5691);
+       ext_grs_node_t *n_MultipleAdd5707_1392 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5707_1392", grs_op_MultipleAdd, mode_P, 39, n_MultipleAdd5707);
+       ext_grs_node_t *n_MultipleAdd5697_1393 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5697_1393", grs_op_MultipleAdd, mode_P, 38, n_MultipleAdd5697);
+       ext_grs_node_t *n_Load799_1394 = ext_grs_act_add_node_to_keep(pattern, "Load799_1394", grs_op_Load, mode_T, 36, n_Load799);
+       ext_grs_node_t *n_VProj87_1395 = ext_grs_act_add_node_to_keep(pattern, "VProj87_1395", grs_op_VProj, mode_Bu, 89, n_Vector_Result8_Proj861);
+       ext_grs_node_t *n_VProj113_1396 = ext_grs_act_add_node_to_keep(pattern, "VProj113_1396", grs_op_VProj, mode_Bu, 90, n_Vector_Result6_Proj831);
+       ext_grs_node_t *n_Proj845_1397 = ext_grs_act_add_node_to_keep(pattern, "Proj845_1397", grs_op_Proj, mode_M, 45, n_Proj845);
+       ext_grs_node_t *n_Proj950_1398 = ext_grs_act_add_node_to_keep(pattern, "Proj950_1398", grs_op_Proj, mode_M, 44, n_Proj950);
+       ext_grs_node_t *n_MultipleAdd5695_1399 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5695_1399", grs_op_MultipleAdd, mode_P, 43, n_MultipleAdd5695);
+       ext_grs_node_t *n_MultipleAdd5709_1400 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5709_1400", grs_op_MultipleAdd, mode_P, 41, n_MultipleAdd5709);
+       ext_grs_node_t *n_VProj85_1401 = ext_grs_act_add_node_to_keep(pattern, "VProj85_1401", grs_op_VProj, mode_Bu, 91, n_Vector_Result11_Proj906);
+       ext_grs_node_t *n_VProj95_1402 = ext_grs_act_add_node_to_keep(pattern, "VProj95_1402", grs_op_VProj, mode_Bu, 92, n_Vector_Result5_Proj816);
+       ext_grs_node_t *n_Load904_1403 = ext_grs_act_add_node_to_keep(pattern, "Load904_1403", grs_op_Load, mode_T, 47, n_Load904);
+       ext_grs_node_t *n_Load784_1404 = ext_grs_act_add_node_to_keep(pattern, "Load784_1404", grs_op_Load, mode_T, 48, n_Load784);
+       ext_grs_node_t *n_MultipleAdd5699_1405 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5699_1405", grs_op_MultipleAdd, mode_P, 50, n_MultipleAdd5699);
+       ext_grs_node_t *n_Proj905_1406 = ext_grs_act_add_node_to_keep(pattern, "Proj905_1406", grs_op_Proj, mode_M, 49, n_Proj905);
+       ext_grs_node_t *n_Const794_1407 = ext_grs_act_add_node_to_keep(pattern, "Const794_1407", grs_op_Const, mode_Is, 51, n_Const794);
+       ext_grs_node_t *n_Const914_1408 = ext_grs_act_add_node_to_keep(pattern, "Const914_1408", grs_op_Const, mode_Is, 52, n_Const914);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 93);
+       ext_grs_node_t *n_Load859_1409 = ext_grs_act_add_node_to_keep(pattern, "Load859_1409", grs_op_Load, mode_T, 53, n_Load859);
+       ext_grs_node_t *n_Const944_1410 = ext_grs_act_add_node_to_keep(pattern, "Const944_1410", grs_op_Const, mode_Is, 54, n_Const944);
+       ext_grs_node_t *n_Proj860_1411 = ext_grs_act_add_node_to_keep(pattern, "Proj860_1411", grs_op_Proj, mode_M, 55, n_Proj860);
+       ext_grs_node_t *n_IR_node5724_1412 = ext_grs_act_add_node_to_keep(pattern, "IR_node5724_1412", grs_op_IR_node, mode_ANY, 56, n_IR_node5724);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 94);
+       ext_grs_node_t *n_MultipleAdd5701_1413 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5701_1413", grs_op_MultipleAdd, mode_P, 57, n_MultipleAdd5701);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 95);
+       ext_grs_node_t *n_MultipleAdd5705_1414 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5705_1414", grs_op_MultipleAdd, mode_P, 58, n_MultipleAdd5705);
+       ext_grs_node_t *n_MultipleAdd5703_1415 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5703_1415", grs_op_MultipleAdd, mode_P, 59, n_MultipleAdd5703);
+       ext_grs_node_t *n_VProj93_1416 = ext_grs_act_add_node_to_keep(pattern, "VProj93_1416", grs_op_VProj, mode_Bu, 96, n_Vector_Result4_Proj801);
+       ext_grs_node_t *n_Bad83 = ext_grs_act_add_node(pattern, "Bad83", grs_op_Bad, mode_ANY, 97);
+       ext_grs_node_t *n_VProj83_1417 = ext_grs_act_add_node_to_keep(pattern, "VProj83_1417", grs_op_VProj, mode_Bu, 98, n_Vector_Result0_Proj741);
+       ext_grs_node_t *n_Proj815_1418 = ext_grs_act_add_node_to_keep(pattern, "Proj815_1418", grs_op_Proj, mode_M, 62, n_Proj815);
+       ext_grs_node_t *n_Proj755_1419 = ext_grs_act_add_node_to_keep(pattern, "Proj755_1419", grs_op_Proj, mode_M, 63, n_Proj755);
+       ext_grs_node_t *n_Load814_1420 = ext_grs_act_add_node_to_keep(pattern, "Load814_1420", grs_op_Load, mode_T, 64, n_Load814);
+       ext_grs_node_t *n_VProj107_1421 = ext_grs_act_add_node_to_keep(pattern, "VProj107_1421", grs_op_VProj, mode_Bu, 99, n_Vector_Result3_Proj786);
+       ext_grs_node_t *n_Load754_1422 = ext_grs_act_add_node_to_keep(pattern, "Load754_1422", grs_op_Load, mode_T, 66, n_Load754);
+       ext_grs_node_t *n_Const809_1423 = ext_grs_act_add_node_to_keep(pattern, "Const809_1423", grs_op_Const, mode_Is, 67, n_Const809);
+       ext_grs_node_t *n_Const779_1424 = ext_grs_act_add_node_to_keep(pattern, "Const779_1424", grs_op_Const, mode_Is, 68, n_Const779);
+       ext_grs_node_t *n_Vector_op_Block_1425 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1425", grs_op_Block, mode_BB, 69, n_Vector_op_Block);
+       ext_grs_node_t *n_Load919_1426 = ext_grs_act_add_node_to_keep(pattern, "Load919_1426", grs_op_Load, mode_T, 71, n_Load919);
+       ext_grs_node_t *n_Load964_1427 = ext_grs_act_add_node_to_keep(pattern, "Load964_1427", grs_op_Load, mode_T, 70, n_Load964);
+       ext_grs_node_t *n_VProj97_1428 = ext_grs_act_add_node_to_keep(pattern, "VProj97_1428", grs_op_VProj, mode_Bu, 100, n_Vector_Result10_Proj891);
+       ext_grs_node_t *n_Const735_1429 = ext_grs_act_add_node_to_keep(pattern, "Const735_1429", grs_op_Const, mode_Is, 73, n_Const735);
+       ext_grs_node_t *n_VProj89_1430 = ext_grs_act_add_node_to_keep(pattern, "VProj89_1430", grs_op_VProj, mode_Bu, 101, n_Vector_Result2_Proj771);
+       ext_grs_node_t *n_Const731_1431 = ext_grs_act_add_node_to_keep(pattern, "Const731_1431", grs_op_Const, mode_Is, 75, n_Const731);
+       ext_grs_node_t *n_Proj965_1432 = ext_grs_act_add_node_to_keep(pattern, "Proj965_1432", grs_op_Proj, mode_M, 78, n_Proj965);
+       ext_grs_node_t *n_Proj770_1433 = ext_grs_act_add_node_to_keep(pattern, "Proj770_1433", grs_op_Proj, mode_M, 77, n_Proj770);
+       ext_grs_node_t *n_Proj830_1434 = ext_grs_act_add_node_to_keep(pattern, "Proj830_1434", grs_op_Proj, mode_M, 76, n_Proj830);
+       ext_grs_node_t *n_Load769_1435 = ext_grs_act_add_node_to_keep(pattern, "Load769_1435", grs_op_Load, mode_T, 79, n_Load769);
+       ext_grs_node_t *n_VProj111_1436 = ext_grs_act_add_node_to_keep(pattern, "VProj111_1436", grs_op_VProj, mode_Bu, 102, n_Vector_Result15_Proj966);
+       ext_grs_node_t *n_Proj920_1437 = ext_grs_act_add_node_to_keep(pattern, "Proj920_1437", grs_op_Proj, mode_M, 81, n_Proj920);
+       ext_grs_node_t *n_Const839_1438 = ext_grs_act_add_node_to_keep(pattern, "Const839_1438", grs_op_Const, mode_Is, 82, n_Const839);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_149_1439 = ext_grs_act_add_edge_to_keep(pattern, "pos1_149_1439", 0, n_Load799_1394, n_Proj800_1385, 1, e_pos1_149);
+       ext_grs_edge_t *e_pos1_148_1440 = ext_grs_act_add_edge_to_keep(pattern, "pos1_148_1440", 0, n_Load874_1358, n_Proj875_1373, 2, e_pos1_148);
+       ext_grs_edge_t *e_pos2_178_1441 = ext_grs_act_add_edge_to_keep(pattern, "pos2_178_1441", 1, n_MultipleAdd5691_1391, n_Load964_1427, 3, e_pos2_178);
+       ext_grs_edge_t *e_e133_1442 = ext_grs_act_add_edge_to_keep(pattern, "e133_1442", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5707_1392, 4, e_e133);
+       ext_grs_edge_t *e_e132_1443 = ext_grs_act_add_edge_to_keep(pattern, "e132_1443", ext_grs_NO_EDGE_POS, n_Const839_1438, n_MultipleAdd5707_1392, 5, e_e132);
+       ext_grs_edge_t *e_e134_1444 = ext_grs_act_add_edge_to_keep(pattern, "e134_1444", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5707_1392, 6, e_e134);
+       ext_grs_edge_t *e_e83_1445 = ext_grs_act_add_edge_to_keep(pattern, "e83_1445", ext_grs_NO_EDGE_POS, n_Const731_1431, n_MultipleAdd5701_1413, 7, e_e83);
+       ext_grs_edge_t *e_pos1_136_1446 = ext_grs_act_add_edge_to_keep(pattern, "pos1_136_1446", 0, n_Load859_1409, n_Proj860_1411, 8, e_pos1_136);
+       ext_grs_edge_t *e_pos1_138_1447 = ext_grs_act_add_edge_to_keep(pattern, "pos1_138_1447", 0, n_Load784_1404, n_Proj785_1390, 9, e_pos1_138);
+       ext_grs_edge_t *e_pos1_130_1448 = ext_grs_act_add_edge_to_keep(pattern, "pos1_130_1448", 0, n_Load964_1427, n_Proj965_1432, 11, e_pos1_130);
+       ext_grs_edge_t *e_e85_1449 = ext_grs_act_add_edge_to_keep(pattern, "e85_1449", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5701_1413, 12, e_e85);
+       ext_grs_edge_t *e_e84_1450 = ext_grs_act_add_edge_to_keep(pattern, "e84_1450", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5701_1413, 14, e_e84);
+       ext_grs_edge_t *e_e120_1451 = ext_grs_act_add_edge_to_keep(pattern, "e120_1451", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5705_1414, 15, e_e120);
+       ext_grs_edge_t *e_e124_1452 = ext_grs_act_add_edge_to_keep(pattern, "e124_1452", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5697_1393, 16, e_e124);
+       ext_grs_edge_t *e_e123_1453 = ext_grs_act_add_edge_to_keep(pattern, "e123_1453", ext_grs_NO_EDGE_POS, n_Const914_1408, n_MultipleAdd5697_1393, 17, e_e123);
+       ext_grs_edge_t *e_pos1_89_1454 = ext_grs_act_add_edge_to_keep(pattern, "pos1_89_1454", 0, n_Load814_1420, n_Proj815_1418, 18, e_pos1_89);
+       ext_grs_edge_t *e_e128_1455 = ext_grs_act_add_edge_to_keep(pattern, "e128_1455", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5723_1361, 20, e_e128);
+       ext_grs_edge_t *e_pos2_107_1456 = ext_grs_act_add_edge_to_keep(pattern, "pos2_107_1456", 1, n_MultipleAdd5705_1414, n_Load859_1409, 21, e_pos2_107);
+       ext_grs_edge_t *e_e127_1457 = ext_grs_act_add_edge_to_keep(pattern, "e127_1457", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5723_1361, 23, e_e127);
+       ext_grs_edge_t *e_e126_1458 = ext_grs_act_add_edge_to_keep(pattern, "e126_1458", ext_grs_NO_EDGE_POS, n_Const727_1365, n_MultipleAdd5723_1361, 24, e_e126);
+       ext_grs_edge_t *e_e125_1459 = ext_grs_act_add_edge_to_keep(pattern, "e125_1459", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5697_1393, 25, e_e125);
+       ext_grs_edge_t *e_pos2_184_1460 = ext_grs_act_add_edge(pattern, "pos2_184_1460", 1, n_Bad83, n_Vector_op, 97);
+       ext_grs_edge_t *e_pos2_117_1461 = ext_grs_act_add_edge_to_keep(pattern, "pos2_117_1461", 1, n_MultipleAdd5695_1399, n_Load934_1367, 26, e_pos2_117);
+       ext_grs_edge_t *e_pos2_116_1462 = ext_grs_act_add_edge_to_keep(pattern, "pos2_116_1462", 1, n_MultipleAdd5717_1368, n_Load769_1435, 27, e_pos2_116);
+       ext_grs_edge_t *e_pos1_165_1463 = ext_grs_act_add_edge_to_keep(pattern, "pos1_165_1463", 0, n_Load904_1403, n_Proj905_1406, 30, e_pos1_165);
+       ext_grs_edge_t *e_e111_1464 = ext_grs_act_add_edge_to_keep(pattern, "e111_1464", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5719_1366, 32, e_e111);
+       ext_grs_edge_t *e_e110_1465 = ext_grs_act_add_edge_to_keep(pattern, "e110_1465", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5719_1366, 33, e_e110);
+       ext_grs_edge_t *e_e113_1466 = ext_grs_act_add_edge_to_keep(pattern, "e113_1466", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5695_1399, 34, e_e113);
+       ext_grs_edge_t *e_e112_1467 = ext_grs_act_add_edge_to_keep(pattern, "e112_1467", ext_grs_NO_EDGE_POS, n_Const929_1370, n_MultipleAdd5695_1399, 35, e_e112);
+       ext_grs_edge_t *e_e119_1468 = ext_grs_act_add_edge_to_keep(pattern, "e119_1468", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5705_1414, 36, e_e119);
+       ext_grs_edge_t *e_e118_1469 = ext_grs_act_add_edge_to_keep(pattern, "e118_1469", ext_grs_NO_EDGE_POS, n_Const854_1376, n_MultipleAdd5705_1414, 37, e_e118);
+       ext_grs_edge_t *e_e114_1470 = ext_grs_act_add_edge_to_keep(pattern, "e114_1470", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5695_1399, 38, e_e114);
+       ext_grs_edge_t *e_pos1_158_1471 = ext_grs_act_add_edge_to_keep(pattern, "pos1_158_1471", 0, n_Load889_1384, n_Proj890_1379, 40, e_pos1_158);
+       ext_grs_edge_t *e_e102_1472 = ext_grs_act_add_edge_to_keep(pattern, "e102_1472", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5703_1415, 43, e_e102);
+       ext_grs_edge_t *e_e101_1473 = ext_grs_act_add_edge_to_keep(pattern, "e101_1473", ext_grs_NO_EDGE_POS, n_Const869_1374, n_MultipleAdd5703_1415, 44, e_e101);
+       ext_grs_edge_t *e_e109_1474 = ext_grs_act_add_edge_to_keep(pattern, "e109_1474", ext_grs_NO_EDGE_POS, n_Const735_1429, n_MultipleAdd5719_1366, 45, e_e109);
+       ext_grs_edge_t *e_e103_1475 = ext_grs_act_add_edge_to_keep(pattern, "e103_1475", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5703_1415, 46, e_e103);
+       ext_grs_edge_t *e_pos1_182_1476 = ext_grs_act_add_edge(pattern, "pos1_182_1476", 0, n_Vector_op, n_Vector_op_ProjData, 98);
+       ext_grs_edge_t *e_e140_1477 = ext_grs_act_add_edge_to_keep(pattern, "e140_1477", ext_grs_NO_EDGE_POS, n_Const899_1383, n_MultipleAdd5699_1405, 47, e_e140);
+       ext_grs_edge_t *e_pos1_183_1478 = ext_grs_act_add_edge(pattern, "pos1_183_1478", 0, n_MultipleAdd5723_1361, n_Vector_op, 99);
+       ext_grs_edge_t *e_e141_1479 = ext_grs_act_add_edge_to_keep(pattern, "e141_1479", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5699_1405, 49, e_e141);
+       ext_grs_edge_t *e_e142_1480 = ext_grs_act_add_edge_to_keep(pattern, "e142_1480", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5699_1405, 50, e_e142);
+       ext_grs_edge_t *e_pos1_187_1481 = ext_grs_act_add_edge(pattern, "pos1_187_1481", 0, n_Vector_op_ProjData, n_VProj83_1417, 100);
+       ext_grs_edge_t *e_e145_1482 = ext_grs_act_add_edge_to_keep(pattern, "e145_1482", ext_grs_NO_EDGE_POS, n_Const824_1378, n_MultipleAdd5709_1400, 51, e_e145);
+       ext_grs_edge_t *e_e146_1483 = ext_grs_act_add_edge_to_keep(pattern, "e146_1483", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5709_1400, 52, e_e146);
+       ext_grs_edge_t *e_pos1_185_1484 = ext_grs_act_add_edge(pattern, "pos1_185_1484", 0, n_Vector_op, n_Vector_op_ProjM, 101);
+       ext_grs_edge_t *e_pos0_180_1485 = ext_grs_act_add_edge(pattern, "pos0_180_1485", -1, n_Vector_op_Block_1425, n_Vector_op, 102);
+       ext_grs_edge_t *e_e147_1486 = ext_grs_act_add_edge_to_keep(pattern, "e147_1486", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5709_1400, 53, e_e147);
+       ext_grs_edge_t *e_pos2_135_1487 = ext_grs_act_add_edge_to_keep(pattern, "pos2_135_1487", 1, n_MultipleAdd5713_1381, n_Load799_1394, 54, e_pos2_135);
+       ext_grs_edge_t *e_pos1_188_1488 = ext_grs_act_add_edge(pattern, "pos1_188_1488", 0, n_Vector_op_ProjData, n_VProj85_1401, 103);
+       ext_grs_edge_t *e_pos1_189_1489 = ext_grs_act_add_edge(pattern, "pos1_189_1489", 0, n_Vector_op_ProjData, n_VProj87_1395, 104);
+       ext_grs_edge_t *e_pos1_200_1490 = ext_grs_act_add_edge(pattern, "pos1_200_1490", 0, n_Vector_op_ProjData, n_VProj109_1362, 105);
+       ext_grs_edge_t *e_pos1_202_1491 = ext_grs_act_add_edge(pattern, "pos1_202_1491", 0, n_Vector_op_ProjData, n_VProj113_1396, 106);
+       ext_grs_edge_t *e_pos2_137_1492 = ext_grs_act_add_edge_to_keep(pattern, "pos2_137_1492", 1, n_MultipleAdd5711_1387, n_Load814_1420, 55, e_pos2_137);
+       ext_grs_edge_t *e_pos1_201_1493 = ext_grs_act_add_edge(pattern, "pos1_201_1493", 0, n_Vector_op_ProjData, n_VProj111_1436, 107);
+       ext_grs_edge_t *e_pos1_104_1494 = ext_grs_act_add_edge_to_keep(pattern, "pos1_104_1494", 0, n_Load829_1371, n_Proj830_1434, 57, e_pos1_104);
+       ext_grs_edge_t *e_pos1_190_1495 = ext_grs_act_add_edge(pattern, "pos1_190_1495", 0, n_Vector_op_ProjData, n_VProj89_1430, 108);
+       ext_grs_edge_t *e_pos1_105_1496 = ext_grs_act_add_edge_to_keep(pattern, "pos1_105_1496", 0, n_Load754_1422, n_Proj755_1419, 58, e_pos1_105);
+       ext_grs_edge_t *e_pos0_177_1497 = ext_grs_act_add_edge_to_keep(pattern, "pos0_177_1497", -1, n_Vector_op_Block_1425, n_Load964_1427, 59, e_pos0_177);
+       ext_grs_edge_t *e_e156_1498 = ext_grs_act_add_edge_to_keep(pattern, "e156_1498", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5711_1387, 61, e_e156);
+       ext_grs_edge_t *e_e154_1499 = ext_grs_act_add_edge_to_keep(pattern, "e154_1499", ext_grs_NO_EDGE_POS, n_Const809_1423, n_MultipleAdd5711_1387, 62, e_e154);
+       ext_grs_edge_t *e_e155_1500 = ext_grs_act_add_edge_to_keep(pattern, "e155_1500", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5711_1387, 64, e_e155);
+       ext_grs_edge_t *e_pos2_143_1501 = ext_grs_act_add_edge_to_keep(pattern, "pos2_143_1501", 1, n_MultipleAdd5701_1413, n_Load889_1384, 65, e_pos2_143);
+       ext_grs_edge_t *e_pos1_179_1502 = ext_grs_act_add_edge_to_keep(pattern, "pos1_179_1502", 0, n_Load919_1426, n_Proj920_1437, 66, e_pos1_179);
+       ext_grs_edge_t *e_pos0_181_1503 = ext_grs_act_add_edge(pattern, "pos0_181_1503", -1, n_Vector_op_Block_1425, n_Vector_op_ProjData, 109);
+       ext_grs_edge_t *e_pos0_186_1504 = ext_grs_act_add_edge(pattern, "pos0_186_1504", -1, n_Vector_op_Block_1425, n_Vector_op_ProjM, 110);
+       ext_grs_edge_t *e_pos2_153_1505 = ext_grs_act_add_edge_to_keep(pattern, "pos2_153_1505", 1, n_MultipleAdd5719_1366, n_Load754_1422, 67, e_pos2_153);
+       ext_grs_edge_t *e_pos2_151_1506 = ext_grs_act_add_edge_to_keep(pattern, "pos2_151_1506", 1, n_MultipleAdd5707_1392, n_Load844_1377, 68, e_pos2_151);
+       ext_grs_edge_t *e_e162_1507 = ext_grs_act_add_edge_to_keep(pattern, "e162_1507", ext_grs_NO_EDGE_POS, n_Const794_1407, n_MultipleAdd5713_1381, 69, e_e162);
+       ext_grs_edge_t *e_e163_1508 = ext_grs_act_add_edge_to_keep(pattern, "e163_1508", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5713_1381, 70, e_e163);
+       ext_grs_edge_t *e_e164_1509 = ext_grs_act_add_edge_to_keep(pattern, "e164_1509", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5713_1381, 71, e_e164);
+       ext_grs_edge_t *e_pos2_157_1510 = ext_grs_act_add_edge_to_keep(pattern, "pos2_157_1510", 1, n_MultipleAdd5697_1393, n_Load919_1426, 72, e_pos2_157);
+       ext_grs_edge_t *e_pos1_90_1511 = ext_grs_act_add_edge_to_keep(pattern, "pos1_90_1511", 0, n_Load739_1369, n_Proj740_1364, 74, e_pos1_90);
+       ext_grs_edge_t *e_e97_1512 = ext_grs_act_add_edge_to_keep(pattern, "e97_1512", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5693_1388, 73, e_e97);
+       ext_grs_edge_t *e_e95_1513 = ext_grs_act_add_edge_to_keep(pattern, "e95_1513", ext_grs_NO_EDGE_POS, n_Const944_1410, n_MultipleAdd5693_1388, 75, e_e95);
+       ext_grs_edge_t *e_e96_1514 = ext_grs_act_add_edge_to_keep(pattern, "e96_1514", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5693_1388, 77, e_e96);
+       ext_grs_edge_t *e_pos1_121_1515 = ext_grs_act_add_edge_to_keep(pattern, "pos1_121_1515", 0, n_Load844_1377, n_Proj845_1397, 76, e_pos1_121);
+       ext_grs_edge_t *e_pos2_94_1516 = ext_grs_act_add_edge_to_keep(pattern, "pos2_94_1516", 1, n_MultipleAdd5723_1361, n_Load739_1369, 78, e_pos2_94);
+       ext_grs_edge_t *e_pos1_98_1517 = ext_grs_act_add_edge_to_keep(pattern, "pos1_98_1517", 0, n_Load934_1367, n_Proj935_1363, 79, e_pos1_98);
+       ext_grs_edge_t *e_e171_1518 = ext_grs_act_add_edge_to_keep(pattern, "e171_1518", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5715_1382, 80, e_e171);
+       ext_grs_edge_t *e_e170_1519 = ext_grs_act_add_edge_to_keep(pattern, "e170_1519", ext_grs_NO_EDGE_POS, n_Const779_1424, n_MultipleAdd5715_1382, 81, e_e170);
+       ext_grs_edge_t *e_e93_1520 = ext_grs_act_add_edge_to_keep(pattern, "e93_1520", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5717_1368, 84, e_e93);
+       ext_grs_edge_t *e_pos1_122_1521 = ext_grs_act_add_edge_to_keep(pattern, "pos1_122_1521", 0, n_Load769_1435, n_Proj770_1433, 83, e_pos1_122);
+       ext_grs_edge_t *e_e91_1522 = ext_grs_act_add_edge_to_keep(pattern, "e91_1522", ext_grs_NO_EDGE_POS, n_Const764_1356, n_MultipleAdd5717_1368, 85, e_e91);
+       ext_grs_edge_t *e_e92_1523 = ext_grs_act_add_edge_to_keep(pattern, "e92_1523", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5717_1368, 87, e_e92);
+       ext_grs_edge_t *e_pos2_99_1524 = ext_grs_act_add_edge_to_keep(pattern, "pos2_99_1524", 1, n_MultipleAdd5699_1405, n_Load904_1403, 86, e_pos2_99);
+       ext_grs_edge_t *e_pos2_161_1525 = ext_grs_act_add_edge_to_keep(pattern, "pos2_161_1525", 1, n_MultipleAdd5703_1415, n_Load874_1358, 88, e_pos2_161);
+       ext_grs_edge_t *e_pos1_195_1526 = ext_grs_act_add_edge(pattern, "pos1_195_1526", 0, n_Vector_op_ProjData, n_VProj99_1372, 111);
+       ext_grs_edge_t *e_pos1_196_1527 = ext_grs_act_add_edge(pattern, "pos1_196_1527", 0, n_Vector_op_ProjData, n_VProj101_1359, 112);
+       ext_grs_edge_t *e_pos1_197_1528 = ext_grs_act_add_edge(pattern, "pos1_197_1528", 0, n_Vector_op_ProjData, n_VProj103_1360, 113);
+       ext_grs_edge_t *e_pos1_198_1529 = ext_grs_act_add_edge(pattern, "pos1_198_1529", 0, n_Vector_op_ProjData, n_VProj105_1380, 114);
+       ext_grs_edge_t *e_e174_1530 = ext_grs_act_add_edge_to_keep(pattern, "e174_1530", ext_grs_NO_EDGE_POS, n_Arg_0_1375, n_MultipleAdd5691_1391, 89, e_e174);
+       ext_grs_edge_t *e_pos1_191_1531 = ext_grs_act_add_edge(pattern, "pos1_191_1531", 0, n_Vector_op_ProjData, n_VProj91_1386, 115);
+       ext_grs_edge_t *e_e175_1532 = ext_grs_act_add_edge_to_keep(pattern, "e175_1532", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5691_1391, 90, e_e175);
+       ext_grs_edge_t *e_pos1_192_1533 = ext_grs_act_add_edge(pattern, "pos1_192_1533", 0, n_Vector_op_ProjData, n_VProj93_1416, 116);
+       ext_grs_edge_t *e_e172_1534 = ext_grs_act_add_edge_to_keep(pattern, "e172_1534", ext_grs_NO_EDGE_POS, n_IR_node5724_1412, n_MultipleAdd5715_1382, 91, e_e172);
+       ext_grs_edge_t *e_pos1_193_1535 = ext_grs_act_add_edge(pattern, "pos1_193_1535", 0, n_Vector_op_ProjData, n_VProj95_1402, 117);
+       ext_grs_edge_t *e_e173_1536 = ext_grs_act_add_edge_to_keep(pattern, "e173_1536", ext_grs_NO_EDGE_POS, n_Const959_1357, n_MultipleAdd5691_1391, 92, e_e173);
+       ext_grs_edge_t *e_pos1_194_1537 = ext_grs_act_add_edge(pattern, "pos1_194_1537", 0, n_Vector_op_ProjData, n_VProj97_1428, 118);
+       ext_grs_edge_t *e_pos2_169_1538 = ext_grs_act_add_edge_to_keep(pattern, "pos2_169_1538", 1, n_MultipleAdd5693_1388, n_Load949_1389, 93, e_pos2_169);
+       ext_grs_edge_t *e_pos1_199_1539 = ext_grs_act_add_edge(pattern, "pos1_199_1539", 0, n_Vector_op_ProjData, n_VProj107_1421, 119);
+       ext_grs_edge_t *e_pos2_166_1540 = ext_grs_act_add_edge_to_keep(pattern, "pos2_166_1540", 1, n_MultipleAdd5715_1382, n_Load784_1404, 94, e_pos2_166);
+       ext_grs_edge_t *e_pos2_87_1541 = ext_grs_act_add_edge_to_keep(pattern, "pos2_87_1541", 1, n_MultipleAdd5709_1400, n_Load829_1371, 95, e_pos2_87);
+       ext_grs_edge_t *e_pos1_115_1542 = ext_grs_act_add_edge_to_keep(pattern, "pos1_115_1542", 0, n_Load949_1389, n_Proj950_1398, 96, e_pos1_115);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_34996);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_34999);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35002);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35005);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35008);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35011);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35014);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35017);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35020);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35023);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35026);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35029);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35032);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35035);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35038);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35041);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35044);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_35047);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vload_16b_variant1 */
+
+
+/* functions for evaluation of conditions of action vload_16b_variant2 */
+static int grs_cond_func_35913(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[54/* Const944 */])) == 14;
+}
+static int grs_cond_func_35916(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[9/* Const727 */])) == 0;
+}
+static int grs_cond_func_35919(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[57/* MultipleAdd5701 */]) == 4;
+}
+static int grs_cond_func_35922(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[61/* Vector_Result0_Proj741 */]) == 3;
+}
+static int grs_cond_func_35925(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[63/* Proj815 */]) == 0;
+}
+static int grs_cond_func_35928(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[42/* Vector_Result11_Proj906 */]) == 3;
+}
+static int grs_cond_func_35931(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[8/* Proj740 */]) == 0;
+}
+static int grs_cond_func_35934(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[12/* MultipleAdd5717 */]) == 4;
+}
+static int grs_cond_func_35937(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[33/* MultipleAdd5693 */]) == 4;
+}
+static int grs_cond_func_35940(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[1/* Const959 */])) == 15;
+}
+static int grs_cond_func_35943(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[7/* Proj935 */]) == 0;
+}
+static int grs_cond_func_35946(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[37/* Vector_Result8_Proj861 */]) == 3;
+}
+static int grs_cond_func_35949(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[60/* MultipleAdd5703 */]) == 4;
+}
+static int grs_cond_func_35952(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[22/* Const824 */])) == 6;
+}
+static int grs_cond_func_35955(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[77/* Proj830 */]) == 0;
+}
+static int grs_cond_func_35958(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[64/* Proj755 */]) == 0;
+}
+static int grs_cond_func_35961(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[75/* Vector_Result2_Proj771 */]) == 3;
+}
+static int grs_cond_func_35964(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[10/* MultipleAdd5719 */]) == 4;
+}
+static int grs_cond_func_35967(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[30/* Vector_Result13_Proj936 */]) == 3;
+}
+static int grs_cond_func_35970(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[43/* MultipleAdd5695 */]) == 4;
+}
+static int grs_cond_func_35973(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[44/* Proj950 */]) == 0;
+}
+static int grs_cond_func_35976(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[27/* Const899 */])) == 11;
+}
+static int grs_cond_func_35979(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[58/* MultipleAdd5705 */]) == 4;
+}
+static int grs_cond_func_35982(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[45/* Proj845 */]) == 0;
+}
+static int grs_cond_func_35985(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[78/* Proj770 */]) == 0;
+}
+static int grs_cond_func_35988(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[20/* Const854 */])) == 8;
+}
+static int grs_cond_func_35991(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[38/* MultipleAdd5697 */]) == 4;
+}
+static int grs_cond_func_35994(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[5/* MultipleAdd5723 */]) == 4;
+}
+static int grs_cond_func_35997(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[62/* Vector_Result4_Proj801 */]) == 3;
+}
+static int grs_cond_func_36000(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[79/* Proj965 */]) == 0;
+}
+static int grs_cond_func_36003(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[46/* Vector_Result5_Proj816 */]) == 3;
+}
+static int grs_cond_func_36006(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[0/* Const764 */])) == 2;
+}
+static int grs_cond_func_36009(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[39/* MultipleAdd5707 */]) == 4;
+}
+static int grs_cond_func_36012(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[14/* Const929 */])) == 13;
+}
+static int grs_cond_func_36015(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[55/* Proj860 */]) == 0;
+}
+static int grs_cond_func_36018(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[35/* Proj785 */]) == 0;
+}
+static int grs_cond_func_36021(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[73/* Vector_Result10_Proj891 */]) == 3;
+}
+static int grs_cond_func_36024(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[50/* MultipleAdd5699 */]) == 4;
+}
+static int grs_cond_func_36027(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[41/* MultipleAdd5709 */]) == 4;
+}
+static int grs_cond_func_36030(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[16/* Vector_Result7_Proj846 */]) == 3;
+}
+static int grs_cond_func_36033(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[51/* Const794 */])) == 4;
+}
+static int grs_cond_func_36036(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj875 */]) == 0;
+}
+static int grs_cond_func_36039(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[29/* Proj800 */]) == 0;
+}
+static int grs_cond_func_36042(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[68/* Const809 */])) == 5;
+}
+static int grs_cond_func_36045(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[3/* Vector_Result1_Proj756 */]) == 3;
+}
+static int grs_cond_func_36048(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[4/* Vector_Result12_Proj921 */]) == 3;
+}
+static int grs_cond_func_36051(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[76/* Const731 */])) == 10;
+}
+static int grs_cond_func_36054(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[31/* MultipleAdd5711 */]) == 4;
+}
+static int grs_cond_func_36057(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[23/* Proj890 */]) == 0;
+}
+static int grs_cond_func_36060(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[25/* Vector_Result9_Proj876 */]) == 3;
+}
+static int grs_cond_func_36063(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[83/* Const839 */])) == 7;
+}
+static int grs_cond_func_36066(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[66/* Vector_Result3_Proj786 */]) == 3;
+}
+static int grs_cond_func_36069(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[24/* MultipleAdd5713 */]) == 4;
+}
+static int grs_cond_func_36072(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[74/* Const735 */])) == 1;
+}
+static int grs_cond_func_36075(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[52/* Const914 */])) == 12;
+}
+static int grs_cond_func_36078(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[49/* Proj905 */]) == 0;
+}
+static int grs_cond_func_36081(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[6/* Vector_Result14_Proj951 */]) == 3;
+}
+static int grs_cond_func_36084(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[81/* Vector_Result15_Proj966 */]) == 3;
+}
+static int grs_cond_func_36087(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[18/* Const869 */])) == 9;
+}
+static int grs_cond_func_36090(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[26/* MultipleAdd5715 */]) == 4;
+}
+static int grs_cond_func_36093(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[34/* MultipleAdd5691 */]) == 4;
+}
+static int grs_cond_func_36096(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[40/* Vector_Result6_Proj831 */]) == 3;
+}
+static int grs_cond_func_36099(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[82/* Proj920 */]) == 0;
+}
+static int grs_cond_func_36102(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[69/* Const779 */])) == 3;
+}
+
+static void *grs_eval_out_func_36507(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[96/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_36510(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[95/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_36513(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[98/* VProj84 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_36516(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[92/* VProj86 */], 11);
+  return(NULL);
+}
+static void *grs_eval_out_func_36519(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[90/* VProj88 */], 8);
+  return(NULL);
+}
+static void *grs_eval_out_func_36522(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[102/* VProj90 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_36525(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[89/* VProj92 */], 13);
+  return(NULL);
+}
+static void *grs_eval_out_func_36528(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[97/* VProj94 */], 4);
+  return(NULL);
+}
+static void *grs_eval_out_func_36531(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[93/* VProj96 */], 5);
+  return(NULL);
+}
+static void *grs_eval_out_func_36534(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[101/* VProj98 */], 10);
+  return(NULL);
+}
+static void *grs_eval_out_func_36537(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[87/* VProj100 */], 7);
+  return(NULL);
+}
+static void *grs_eval_out_func_36540(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[84/* VProj102 */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_36543(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[85/* VProj104 */], 12);
+  return(NULL);
+}
+static void *grs_eval_out_func_36546(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[88/* VProj106 */], 9);
+  return(NULL);
+}
+static void *grs_eval_out_func_36549(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[99/* VProj108 */], 3);
+  return(NULL);
+}
+static void *grs_eval_out_func_36552(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[86/* VProj110 */], 14);
+  return(NULL);
+}
+static void *grs_eval_out_func_36555(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[103/* VProj112 */], 15);
+  return(NULL);
+}
+static void *grs_eval_out_func_36558(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[91/* VProj114 */], 6);
+  return(NULL);
+}
+/* functions for building the pattern of action vload_16b_variant2 */
+static _inline ext_grs_action_t *grs_action_vload_16b_variant2_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vload_16b_variant2");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Const764 = ext_grs_act_add_node(pattern, "Const764", grs_op_Const, mode_Is, 0);
+    ext_grs_node_t *n_Const959 = ext_grs_act_add_node(pattern, "Const959", grs_op_Const, mode_Is, 1);
+    ext_grs_node_t *n_Load874 = ext_grs_act_add_node(pattern, "Load874", grs_op_Load, mode_T, 2);
+    ext_grs_node_t *n_Vector_Result1_Proj756 = ext_grs_act_add_node(pattern, "Vector_Result1_Proj756", grs_op_Proj, mode_Bu, 3);
+    ext_grs_node_t *n_Vector_Result12_Proj921 = ext_grs_act_add_node(pattern, "Vector_Result12_Proj921", grs_op_Proj, mode_Bu, 4);
+    ext_grs_node_t *n_MultipleAdd5723 = ext_grs_act_add_node(pattern, "MultipleAdd5723", grs_op_MultipleAdd, mode_P, 5);
+    ext_grs_node_t *n_Vector_Result14_Proj951 = ext_grs_act_add_node(pattern, "Vector_Result14_Proj951", grs_op_Proj, mode_Bu, 6);
+    ext_grs_node_t *n_Proj935 = ext_grs_act_add_node(pattern, "Proj935", grs_op_Proj, mode_M, 7);
+    ext_grs_node_t *n_Proj740 = ext_grs_act_add_node(pattern, "Proj740", grs_op_Proj, mode_M, 8);
+    ext_grs_node_t *n_Const727 = ext_grs_act_add_node(pattern, "Const727", grs_op_Const, mode_Is, 9);
+    ext_grs_node_t *n_MultipleAdd5719 = ext_grs_act_add_node(pattern, "MultipleAdd5719", grs_op_MultipleAdd, mode_P, 10);
+    ext_grs_node_t *n_Load934 = ext_grs_act_add_node(pattern, "Load934", grs_op_Load, mode_T, 11);
+    ext_grs_node_t *n_MultipleAdd5717 = ext_grs_act_add_node(pattern, "MultipleAdd5717", grs_op_MultipleAdd, mode_P, 12);
+    ext_grs_node_t *n_Load739 = ext_grs_act_add_node(pattern, "Load739", grs_op_Load, mode_T, 13);
+    ext_grs_node_t *n_Const929 = ext_grs_act_add_node(pattern, "Const929", grs_op_Const, mode_Is, 14);
+    ext_grs_node_t *n_Load829 = ext_grs_act_add_node(pattern, "Load829", grs_op_Load, mode_T, 15);
+    ext_grs_node_t *n_Vector_Result7_Proj846 = ext_grs_act_add_node(pattern, "Vector_Result7_Proj846", grs_op_Proj, mode_Bu, 16);
+    ext_grs_node_t *n_Proj875 = ext_grs_act_add_node(pattern, "Proj875", grs_op_Proj, mode_M, 17);
+    ext_grs_node_t *n_Const869 = ext_grs_act_add_node(pattern, "Const869", grs_op_Const, mode_Is, 18);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 19);
+    ext_grs_node_t *n_Const854 = ext_grs_act_add_node(pattern, "Const854", grs_op_Const, mode_Is, 20);
+    ext_grs_node_t *n_Load844 = ext_grs_act_add_node(pattern, "Load844", grs_op_Load, mode_T, 21);
+    ext_grs_node_t *n_Const824 = ext_grs_act_add_node(pattern, "Const824", grs_op_Const, mode_Is, 22);
+    ext_grs_node_t *n_Proj890 = ext_grs_act_add_node(pattern, "Proj890", grs_op_Proj, mode_M, 23);
+    ext_grs_node_t *n_MultipleAdd5713 = ext_grs_act_add_node(pattern, "MultipleAdd5713", grs_op_MultipleAdd, mode_P, 24);
+    ext_grs_node_t *n_Vector_Result9_Proj876 = ext_grs_act_add_node(pattern, "Vector_Result9_Proj876", grs_op_Proj, mode_Bu, 25);
+    ext_grs_node_t *n_MultipleAdd5715 = ext_grs_act_add_node(pattern, "MultipleAdd5715", grs_op_MultipleAdd, mode_P, 26);
+    ext_grs_node_t *n_Const899 = ext_grs_act_add_node(pattern, "Const899", grs_op_Const, mode_Is, 27);
+    ext_grs_node_t *n_Load889 = ext_grs_act_add_node(pattern, "Load889", grs_op_Load, mode_T, 28);
+    ext_grs_node_t *n_Proj800 = ext_grs_act_add_node(pattern, "Proj800", grs_op_Proj, mode_M, 29);
+    ext_grs_node_t *n_Vector_Result13_Proj936 = ext_grs_act_add_node(pattern, "Vector_Result13_Proj936", grs_op_Proj, mode_Bu, 30);
+    ext_grs_node_t *n_MultipleAdd5711 = ext_grs_act_add_node(pattern, "MultipleAdd5711", grs_op_MultipleAdd, mode_P, 31);
+    ext_grs_node_t *n_Load949 = ext_grs_act_add_node(pattern, "Load949", grs_op_Load, mode_T, 32);
+    ext_grs_node_t *n_MultipleAdd5693 = ext_grs_act_add_node(pattern, "MultipleAdd5693", grs_op_MultipleAdd, mode_P, 33);
+    ext_grs_node_t *n_MultipleAdd5691 = ext_grs_act_add_node(pattern, "MultipleAdd5691", grs_op_MultipleAdd, mode_P, 34);
+    ext_grs_node_t *n_Proj785 = ext_grs_act_add_node(pattern, "Proj785", grs_op_Proj, mode_M, 35);
+    ext_grs_node_t *n_Load799 = ext_grs_act_add_node(pattern, "Load799", grs_op_Load, mode_T, 36);
+    ext_grs_node_t *n_Vector_Result8_Proj861 = ext_grs_act_add_node(pattern, "Vector_Result8_Proj861", grs_op_Proj, mode_Bu, 37);
+    ext_grs_node_t *n_MultipleAdd5697 = ext_grs_act_add_node(pattern, "MultipleAdd5697", grs_op_MultipleAdd, mode_P, 38);
+    ext_grs_node_t *n_MultipleAdd5707 = ext_grs_act_add_node(pattern, "MultipleAdd5707", grs_op_MultipleAdd, mode_P, 39);
+    ext_grs_node_t *n_Vector_Result6_Proj831 = ext_grs_act_add_node(pattern, "Vector_Result6_Proj831", grs_op_Proj, mode_Bu, 40);
+    ext_grs_node_t *n_MultipleAdd5709 = ext_grs_act_add_node(pattern, "MultipleAdd5709", grs_op_MultipleAdd, mode_P, 41);
+    ext_grs_node_t *n_Vector_Result11_Proj906 = ext_grs_act_add_node(pattern, "Vector_Result11_Proj906", grs_op_Proj, mode_Bu, 42);
+    ext_grs_node_t *n_MultipleAdd5695 = ext_grs_act_add_node(pattern, "MultipleAdd5695", grs_op_MultipleAdd, mode_P, 43);
+    ext_grs_node_t *n_Proj950 = ext_grs_act_add_node(pattern, "Proj950", grs_op_Proj, mode_M, 44);
+    ext_grs_node_t *n_Proj845 = ext_grs_act_add_node(pattern, "Proj845", grs_op_Proj, mode_M, 45);
+    ext_grs_node_t *n_Vector_Result5_Proj816 = ext_grs_act_add_node(pattern, "Vector_Result5_Proj816", grs_op_Proj, mode_Bu, 46);
+    ext_grs_node_t *n_Load904 = ext_grs_act_add_node(pattern, "Load904", grs_op_Load, mode_T, 47);
+    ext_grs_node_t *n_Load784 = ext_grs_act_add_node(pattern, "Load784", grs_op_Load, mode_T, 48);
+    ext_grs_node_t *n_Proj905 = ext_grs_act_add_node(pattern, "Proj905", grs_op_Proj, mode_M, 49);
+    ext_grs_node_t *n_MultipleAdd5699 = ext_grs_act_add_node(pattern, "MultipleAdd5699", grs_op_MultipleAdd, mode_P, 50);
+    ext_grs_node_t *n_Const794 = ext_grs_act_add_node(pattern, "Const794", grs_op_Const, mode_Is, 51);
+    ext_grs_node_t *n_Const914 = ext_grs_act_add_node(pattern, "Const914", grs_op_Const, mode_Is, 52);
+    ext_grs_node_t *n_Load859 = ext_grs_act_add_node(pattern, "Load859", grs_op_Load, mode_T, 53);
+    ext_grs_node_t *n_Const944 = ext_grs_act_add_node(pattern, "Const944", grs_op_Const, mode_Is, 54);
+    ext_grs_node_t *n_Proj860 = ext_grs_act_add_node(pattern, "Proj860", grs_op_Proj, mode_M, 55);
+    ext_grs_node_t *n_IR_node5724 = ext_grs_act_add_node(pattern, "IR_node5724", grs_op_IR_node, mode_ANY, 56);
+    ext_grs_node_t *n_MultipleAdd5701 = ext_grs_act_add_node(pattern, "MultipleAdd5701", grs_op_MultipleAdd, mode_P, 57);
+    ext_grs_node_t *n_MultipleAdd5705 = ext_grs_act_add_node(pattern, "MultipleAdd5705", grs_op_MultipleAdd, mode_P, 58);
+    ext_grs_node_t *n_IR_node5725 = ext_grs_act_add_node(pattern, "IR_node5725", grs_op_IR_node, mode_ANY, 59);
+    ext_grs_node_t *n_MultipleAdd5703 = ext_grs_act_add_node(pattern, "MultipleAdd5703", grs_op_MultipleAdd, mode_P, 60);
+    ext_grs_node_t *n_Vector_Result0_Proj741 = ext_grs_act_add_node(pattern, "Vector_Result0_Proj741", grs_op_Proj, mode_Bu, 61);
+    ext_grs_node_t *n_Vector_Result4_Proj801 = ext_grs_act_add_node(pattern, "Vector_Result4_Proj801", grs_op_Proj, mode_Bu, 62);
+    ext_grs_node_t *n_Proj815 = ext_grs_act_add_node(pattern, "Proj815", grs_op_Proj, mode_M, 63);
+    ext_grs_node_t *n_Proj755 = ext_grs_act_add_node(pattern, "Proj755", grs_op_Proj, mode_M, 64);
+    ext_grs_node_t *n_Load814 = ext_grs_act_add_node(pattern, "Load814", grs_op_Load, mode_T, 65);
+    ext_grs_node_t *n_Vector_Result3_Proj786 = ext_grs_act_add_node(pattern, "Vector_Result3_Proj786", grs_op_Proj, mode_Bu, 66);
+    ext_grs_node_t *n_Load754 = ext_grs_act_add_node(pattern, "Load754", grs_op_Load, mode_T, 67);
+    ext_grs_node_t *n_Const809 = ext_grs_act_add_node(pattern, "Const809", grs_op_Const, mode_Is, 68);
+    ext_grs_node_t *n_Const779 = ext_grs_act_add_node(pattern, "Const779", grs_op_Const, mode_Is, 69);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 70);
+    ext_grs_node_t *n_Load964 = ext_grs_act_add_node(pattern, "Load964", grs_op_Load, mode_T, 71);
+    ext_grs_node_t *n_Load919 = ext_grs_act_add_node(pattern, "Load919", grs_op_Load, mode_T, 72);
+    ext_grs_node_t *n_Vector_Result10_Proj891 = ext_grs_act_add_node(pattern, "Vector_Result10_Proj891", grs_op_Proj, mode_Bu, 73);
+    ext_grs_node_t *n_Const735 = ext_grs_act_add_node(pattern, "Const735", grs_op_Const, mode_Is, 74);
+    ext_grs_node_t *n_Vector_Result2_Proj771 = ext_grs_act_add_node(pattern, "Vector_Result2_Proj771", grs_op_Proj, mode_Bu, 75);
+    ext_grs_node_t *n_Const731 = ext_grs_act_add_node(pattern, "Const731", grs_op_Const, mode_Is, 76);
+    ext_grs_node_t *n_Proj830 = ext_grs_act_add_node(pattern, "Proj830", grs_op_Proj, mode_M, 77);
+    ext_grs_node_t *n_Proj770 = ext_grs_act_add_node(pattern, "Proj770", grs_op_Proj, mode_M, 78);
+    ext_grs_node_t *n_Proj965 = ext_grs_act_add_node(pattern, "Proj965", grs_op_Proj, mode_M, 79);
+    ext_grs_node_t *n_Load769 = ext_grs_act_add_node(pattern, "Load769", grs_op_Load, mode_T, 80);
+    ext_grs_node_t *n_Vector_Result15_Proj966 = ext_grs_act_add_node(pattern, "Vector_Result15_Proj966", grs_op_Proj, mode_Bu, 81);
+    ext_grs_node_t *n_Proj920 = ext_grs_act_add_node(pattern, "Proj920", grs_op_Proj, mode_M, 82);
+    ext_grs_node_t *n_Const839 = ext_grs_act_add_node(pattern, "Const839", grs_op_Const, mode_Is, 83);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_147 = ext_grs_act_add_edge(pattern, "pos1_147", 0, n_Load859, n_Proj860, 0);
+    ext_grs_edge_t *e_pos1_149 = ext_grs_act_add_edge(pattern, "pos1_149", 0, n_Load784, n_Proj785, 1);
+    ext_grs_edge_t *e_pos1_141 = ext_grs_act_add_edge(pattern, "pos1_141", 0, n_Load814, n_Vector_Result5_Proj816, 2);
+    ext_grs_edge_t *e_pos1_140 = ext_grs_act_add_edge(pattern, "pos1_140", 0, n_Load964, n_Proj965, 3);
+    ext_grs_edge_t *e_e131 = ext_grs_act_add_edge(pattern, "e131", ext_grs_NO_EDGE_POS, n_Const914, n_MultipleAdd5697, 4);
+    ext_grs_edge_t *e_e133 = ext_grs_act_add_edge(pattern, "e133", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5697, 5);
+    ext_grs_edge_t *e_e132 = ext_grs_act_add_edge(pattern, "e132", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5697, 6);
+    ext_grs_edge_t *e_e135 = ext_grs_act_add_edge(pattern, "e135", ext_grs_NO_EDGE_POS, n_Const727, n_MultipleAdd5723, 7);
+    ext_grs_edge_t *e_e134 = ext_grs_act_add_edge(pattern, "e134", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5697, 8);
+    ext_grs_edge_t *e_e137 = ext_grs_act_add_edge(pattern, "e137", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5723, 9);
+    ext_grs_edge_t *e_e136 = ext_grs_act_add_edge(pattern, "e136", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5723, 10);
+    ext_grs_edge_t *e_pos2_171 = ext_grs_act_add_edge(pattern, "pos2_171", 1, n_MultipleAdd5697, n_Load919, 11);
+    ext_grs_edge_t *e_e138 = ext_grs_act_add_edge(pattern, "e138", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5723, 12);
+    ext_grs_edge_t *e_pos2_175 = ext_grs_act_add_edge(pattern, "pos2_175", 1, n_MultipleAdd5703, n_Load874, 13);
+    ext_grs_edge_t *e_pos1_139 = ext_grs_act_add_edge(pattern, "pos1_139", 0, n_Load799, n_Vector_Result4_Proj801, 14);
+    ext_grs_edge_t *e_pos1_130 = ext_grs_act_add_edge(pattern, "pos1_130", 0, n_Load769, n_Proj770, 15);
+    ext_grs_edge_t *e_e120 = ext_grs_act_add_edge(pattern, "e120", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5695, 16);
+    ext_grs_edge_t *e_pos1_88 = ext_grs_act_add_edge(pattern, "pos1_88", 0, n_Load739, n_Vector_Result0_Proj741, 17);
+    ext_grs_edge_t *e_e121 = ext_grs_act_add_edge(pattern, "e121", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5695, 18);
+    ext_grs_edge_t *e_e128 = ext_grs_act_add_edge(pattern, "e128", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5705, 19);
+    ext_grs_edge_t *e_e127 = ext_grs_act_add_edge(pattern, "e127", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5705, 20);
+    ext_grs_edge_t *e_pos2_181 = ext_grs_act_add_edge(pattern, "pos2_181", 1, n_MultipleAdd5715, n_Load784, 21);
+    ext_grs_edge_t *e_e126 = ext_grs_act_add_edge(pattern, "e126", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5705, 22);
+    ext_grs_edge_t *e_e125 = ext_grs_act_add_edge(pattern, "e125", ext_grs_NO_EDGE_POS, n_Const854, n_MultipleAdd5705, 23);
+    ext_grs_edge_t *e_pos2_184 = ext_grs_act_add_edge(pattern, "pos2_184", 1, n_MultipleAdd5693, n_Load949, 24);
+    ext_grs_edge_t *e_pos1_165 = ext_grs_act_add_edge(pattern, "pos1_165", 0, n_Load919, n_Vector_Result12_Proj921, 25);
+    ext_grs_edge_t *e_pos1_163 = ext_grs_act_add_edge(pattern, "pos1_163", 0, n_Load754, n_Vector_Result1_Proj756, 26);
+    ext_grs_edge_t *e_pos1_162 = ext_grs_act_add_edge(pattern, "pos1_162", 0, n_Load799, n_Proj800, 27);
+    ext_grs_edge_t *e_pos1_161 = ext_grs_act_add_edge(pattern, "pos1_161", 0, n_Load874, n_Proj875, 28);
+    ext_grs_edge_t *e_pos2_195 = ext_grs_act_add_edge(pattern, "pos2_195", 1, n_MultipleAdd5691, n_Load964, 29);
+    ext_grs_edge_t *e_e119 = ext_grs_act_add_edge(pattern, "e119", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5695, 30);
+    ext_grs_edge_t *e_e118 = ext_grs_act_add_edge(pattern, "e118", ext_grs_NO_EDGE_POS, n_Const929, n_MultipleAdd5695, 31);
+    ext_grs_edge_t *e_e115 = ext_grs_act_add_edge(pattern, "e115", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5719, 32);
+    ext_grs_edge_t *e_e114 = ext_grs_act_add_edge(pattern, "e114", ext_grs_NO_EDGE_POS, n_Const735, n_MultipleAdd5719, 33);
+    ext_grs_edge_t *e_e117 = ext_grs_act_add_edge(pattern, "e117", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5719, 34);
+    ext_grs_edge_t *e_e116 = ext_grs_act_add_edge(pattern, "e116", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5719, 35);
+    ext_grs_edge_t *e_pos1_156 = ext_grs_act_add_edge(pattern, "pos1_156", 0, n_Load844, n_Vector_Result7_Proj846, 36);
+    ext_grs_edge_t *e_pos1_150 = ext_grs_act_add_edge(pattern, "pos1_150", 0, n_Load889, n_Vector_Result10_Proj891, 37);
+    ext_grs_edge_t *e_e101 = ext_grs_act_add_edge(pattern, "e101", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5693, 38);
+    ext_grs_edge_t *e_e100 = ext_grs_act_add_edge(pattern, "e100", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5693, 39);
+    ext_grs_edge_t *e_e108 = ext_grs_act_add_edge(pattern, "e108", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5703, 40);
+    ext_grs_edge_t *e_e107 = ext_grs_act_add_edge(pattern, "e107", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5703, 41);
+    ext_grs_edge_t *e_e106 = ext_grs_act_add_edge(pattern, "e106", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5703, 42);
+    ext_grs_edge_t *e_e105 = ext_grs_act_add_edge(pattern, "e105", ext_grs_NO_EDGE_POS, n_Const869, n_MultipleAdd5703, 43);
+    ext_grs_edge_t *e_pos1_182 = ext_grs_act_add_edge(pattern, "pos1_182", 0, n_Load949, n_Vector_Result14_Proj951, 44);
+    ext_grs_edge_t *e_pos1_183 = ext_grs_act_add_edge(pattern, "pos1_183", 0, n_Load964, n_Vector_Result15_Proj966, 45);
+    ext_grs_edge_t *e_pos1_180 = ext_grs_act_add_edge(pattern, "pos1_180", 0, n_Load904, n_Proj905, 46);
+    ext_grs_edge_t *e_pos1_172 = ext_grs_act_add_edge(pattern, "pos1_172", 0, n_Load889, n_Proj890, 47);
+    ext_grs_edge_t *e_pos1_173 = ext_grs_act_add_edge(pattern, "pos1_173", 0, n_Load874, n_Vector_Result9_Proj876, 48);
+    ext_grs_edge_t *e_pos1_174 = ext_grs_act_add_edge(pattern, "pos1_174", 0, n_Load784, n_Vector_Result3_Proj786, 49);
+    ext_grs_edge_t *e_pos1_90 = ext_grs_act_add_edge(pattern, "pos1_90", 0, n_Load904, n_Vector_Result11_Proj906, 50);
+    ext_grs_edge_t *e_pos1_91 = ext_grs_act_add_edge(pattern, "pos1_91", 0, n_Load814, n_Proj815, 51);
+    ext_grs_edge_t *e_pos2_97 = ext_grs_act_add_edge(pattern, "pos2_97", 1, n_MultipleAdd5723, n_Load739, 52);
+    ext_grs_edge_t *e_e98 = ext_grs_act_add_edge(pattern, "e98", ext_grs_NO_EDGE_POS, n_Const944, n_MultipleAdd5693, 53);
+    ext_grs_edge_t *e_e95 = ext_grs_act_add_edge(pattern, "e95", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5717, 54);
+    ext_grs_edge_t *e_pos1_92 = ext_grs_act_add_edge(pattern, "pos1_92", 0, n_Load739, n_Proj740, 55);
+    ext_grs_edge_t *e_e96 = ext_grs_act_add_edge(pattern, "e96", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5717, 56);
+    ext_grs_edge_t *e_e99 = ext_grs_act_add_edge(pattern, "e99", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5693, 57);
+    ext_grs_edge_t *e_e93 = ext_grs_act_add_edge(pattern, "e93", ext_grs_NO_EDGE_POS, n_Const764, n_MultipleAdd5717, 58);
+    ext_grs_edge_t *e_e94 = ext_grs_act_add_edge(pattern, "e94", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5717, 59);
+    ext_grs_edge_t *e_pos0_194 = ext_grs_act_add_edge(pattern, "pos0_194", -1, n_Vector_op_Block, n_Load964, 60);
+    ext_grs_edge_t *e_pos1_196 = ext_grs_act_add_edge(pattern, "pos1_196", 0, n_Load919, n_Proj920, 61);
+    ext_grs_edge_t *e_pos1_193 = ext_grs_act_add_edge(pattern, "pos1_193", 0, n_Load829, n_Vector_Result6_Proj831, 62);
+    ext_grs_edge_t *e_pos2_89 = ext_grs_act_add_edge(pattern, "pos2_89", 1, n_MultipleAdd5709, n_Load829, 63);
+    ext_grs_edge_t *e_e186 = ext_grs_act_add_edge(pattern, "e186", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5715, 64);
+    ext_grs_edge_t *e_e185 = ext_grs_act_add_edge(pattern, "e185", ext_grs_NO_EDGE_POS, n_Const779, n_MultipleAdd5715, 65);
+    ext_grs_edge_t *e_e188 = ext_grs_act_add_edge(pattern, "e188", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5715, 66);
+    ext_grs_edge_t *e_e187 = ext_grs_act_add_edge(pattern, "e187", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5715, 67);
+    ext_grs_edge_t *e_e189 = ext_grs_act_add_edge(pattern, "e189", ext_grs_NO_EDGE_POS, n_Const959, n_MultipleAdd5691, 68);
+    ext_grs_edge_t *e_e190 = ext_grs_act_add_edge(pattern, "e190", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5691, 69);
+    ext_grs_edge_t *e_e191 = ext_grs_act_add_edge(pattern, "e191", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5691, 70);
+    ext_grs_edge_t *e_e192 = ext_grs_act_add_edge(pattern, "e192", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5691, 71);
+    ext_grs_edge_t *e_pos2_103 = ext_grs_act_add_edge(pattern, "pos2_103", 1, n_MultipleAdd5699, n_Load904, 72);
+    ext_grs_edge_t *e_e87 = ext_grs_act_add_edge(pattern, "e87", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5701, 73);
+    ext_grs_edge_t *e_e86 = ext_grs_act_add_edge(pattern, "e86", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5701, 74);
+    ext_grs_edge_t *e_e85 = ext_grs_act_add_edge(pattern, "e85", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5701, 75);
+    ext_grs_edge_t *e_e84 = ext_grs_act_add_edge(pattern, "e84", ext_grs_NO_EDGE_POS, n_Const731, n_MultipleAdd5701, 76);
+    ext_grs_edge_t *e_pos2_112 = ext_grs_act_add_edge(pattern, "pos2_112", 1, n_MultipleAdd5705, n_Load859, 77);
+    ext_grs_edge_t *e_pos2_124 = ext_grs_act_add_edge(pattern, "pos2_124", 1, n_MultipleAdd5695, n_Load934, 78);
+    ext_grs_edge_t *e_pos2_123 = ext_grs_act_add_edge(pattern, "pos2_123", 1, n_MultipleAdd5717, n_Load769, 79);
+    ext_grs_edge_t *e_pos1_109 = ext_grs_act_add_edge(pattern, "pos1_109", 0, n_Load829, n_Proj830, 80);
+    ext_grs_edge_t *e_e142 = ext_grs_act_add_edge(pattern, "e142", ext_grs_NO_EDGE_POS, n_Const839, n_MultipleAdd5707, 81);
+    ext_grs_edge_t *e_e143 = ext_grs_act_add_edge(pattern, "e143", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5707, 82);
+    ext_grs_edge_t *e_e144 = ext_grs_act_add_edge(pattern, "e144", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5707, 83);
+    ext_grs_edge_t *e_e145 = ext_grs_act_add_edge(pattern, "e145", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5707, 84);
+    ext_grs_edge_t *e_pos1_102 = ext_grs_act_add_edge(pattern, "pos1_102", 0, n_Load934, n_Proj935, 85);
+    ext_grs_edge_t *e_pos1_104 = ext_grs_act_add_edge(pattern, "pos1_104", 0, n_Load859, n_Vector_Result8_Proj861, 86);
+    ext_grs_edge_t *e_e152 = ext_grs_act_add_edge(pattern, "e152", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5699, 87);
+    ext_grs_edge_t *e_e153 = ext_grs_act_add_edge(pattern, "e153", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5699, 88);
+    ext_grs_edge_t *e_e151 = ext_grs_act_add_edge(pattern, "e151", ext_grs_NO_EDGE_POS, n_Const899, n_MultipleAdd5699, 89);
+    ext_grs_edge_t *e_e157 = ext_grs_act_add_edge(pattern, "e157", ext_grs_NO_EDGE_POS, n_Const824, n_MultipleAdd5709, 90);
+    ext_grs_edge_t *e_e154 = ext_grs_act_add_edge(pattern, "e154", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5699, 91);
+    ext_grs_edge_t *e_e158 = ext_grs_act_add_edge(pattern, "e158", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5709, 92);
+    ext_grs_edge_t *e_pos2_146 = ext_grs_act_add_edge(pattern, "pos2_146", 1, n_MultipleAdd5713, n_Load799, 93);
+    ext_grs_edge_t *e_e159 = ext_grs_act_add_edge(pattern, "e159", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5709, 94);
+    ext_grs_edge_t *e_pos2_148 = ext_grs_act_add_edge(pattern, "pos2_148", 1, n_MultipleAdd5711, n_Load814, 95);
+    ext_grs_edge_t *e_e160 = ext_grs_act_add_edge(pattern, "e160", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5709, 96);
+    ext_grs_edge_t *e_e167 = ext_grs_act_add_edge(pattern, "e167", ext_grs_NO_EDGE_POS, n_Const809, n_MultipleAdd5711, 97);
+    ext_grs_edge_t *e_e168 = ext_grs_act_add_edge(pattern, "e168", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5711, 98);
+    ext_grs_edge_t *e_e169 = ext_grs_act_add_edge(pattern, "e169", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5711, 99);
+    ext_grs_edge_t *e_pos2_155 = ext_grs_act_add_edge(pattern, "pos2_155", 1, n_MultipleAdd5701, n_Load889, 100);
+    ext_grs_edge_t *e_pos1_129 = ext_grs_act_add_edge(pattern, "pos1_129", 0, n_Load844, n_Proj845, 101);
+    ext_grs_edge_t *e_e170 = ext_grs_act_add_edge(pattern, "e170", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5711, 102);
+    ext_grs_edge_t *e_pos1_122 = ext_grs_act_add_edge(pattern, "pos1_122", 0, n_Load949, n_Proj950, 103);
+    ext_grs_edge_t *e_e178 = ext_grs_act_add_edge(pattern, "e178", ext_grs_NO_EDGE_POS, n_IR_node5724, n_MultipleAdd5713, 104);
+    ext_grs_edge_t *e_e179 = ext_grs_act_add_edge(pattern, "e179", ext_grs_NO_EDGE_POS, n_IR_node5725, n_MultipleAdd5713, 105);
+    ext_grs_edge_t *e_e176 = ext_grs_act_add_edge(pattern, "e176", ext_grs_NO_EDGE_POS, n_Const794, n_MultipleAdd5713, 106);
+    ext_grs_edge_t *e_pos2_164 = ext_grs_act_add_edge(pattern, "pos2_164", 1, n_MultipleAdd5707, n_Load844, 107);
+    ext_grs_edge_t *e_e177 = ext_grs_act_add_edge(pattern, "e177", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5713, 108);
+    ext_grs_edge_t *e_pos2_166 = ext_grs_act_add_edge(pattern, "pos2_166", 1, n_MultipleAdd5719, n_Load754, 109);
+    ext_grs_edge_t *e_pos1_110 = ext_grs_act_add_edge(pattern, "pos1_110", 0, n_Load754, n_Proj755, 110);
+    ext_grs_edge_t *e_pos1_113 = ext_grs_act_add_edge(pattern, "pos1_113", 0, n_Load934, n_Vector_Result13_Proj936, 111);
+    ext_grs_edge_t *e_pos1_111 = ext_grs_act_add_edge(pattern, "pos1_111", 0, n_Load769, n_Vector_Result2_Proj771, 112);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const944};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35913, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const727};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35916, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5701};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35919, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_Proj741};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35922, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj815};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35925, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result11_Proj906};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35928, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj740};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35931, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5717};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35934, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5693};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35937, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const959};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35940, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj935};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35943, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result8_Proj861};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35946, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5703};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35949, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const824};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35952, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj830};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35955, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj755};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35958, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result2_Proj771};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35961, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5719};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35964, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result13_Proj936};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35967, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5695};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35970, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj950};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35973, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const899};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35976, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5705};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35979, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj845};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35982, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj770};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35985, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const854};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35988, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5697};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35991, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5723};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35994, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result4_Proj801};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_35997, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj965};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36000, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result5_Proj816};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36003, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const764};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36006, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5707};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36009, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const929};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36012, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj860};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36015, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj785};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36018, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result10_Proj891};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36021, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5699};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36024, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5709};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36027, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result7_Proj846};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36030, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const794};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36033, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj875};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36036, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj800};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36039, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const809};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36042, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result1_Proj756};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36045, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result12_Proj921};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36048, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const731};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36051, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5711};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36054, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj890};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36057, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result9_Proj876};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36060, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const839};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36063, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result3_Proj786};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36066, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5713};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36069, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const735};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36072, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const914};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36075, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj905};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36078, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result14_Proj951};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36081, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result15_Proj966};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36084, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const869};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36087, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5715};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36090, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5691};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36093, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result6_Proj831};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36096, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj920};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36099, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const779};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_36102, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Const764_1543 = ext_grs_act_add_node_to_keep(pattern, "Const764_1543", grs_op_Const, mode_Is, 0, n_Const764);
+       ext_grs_node_t *n_Const959_1544 = ext_grs_act_add_node_to_keep(pattern, "Const959_1544", grs_op_Const, mode_Is, 1, n_Const959);
+       ext_grs_node_t *n_Load874_1545 = ext_grs_act_add_node_to_keep(pattern, "Load874_1545", grs_op_Load, mode_T, 2, n_Load874);
+       ext_grs_node_t *n_VProj102_1546 = ext_grs_act_add_node_to_keep(pattern, "VProj102_1546", grs_op_VProj, mode_Bu, 84, n_Vector_Result1_Proj756);
+       ext_grs_node_t *n_VProj104_1547 = ext_grs_act_add_node_to_keep(pattern, "VProj104_1547", grs_op_VProj, mode_Bu, 85, n_Vector_Result12_Proj921);
+       ext_grs_node_t *n_MultipleAdd5723_1548 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5723_1548", grs_op_MultipleAdd, mode_P, 5, n_MultipleAdd5723);
+       ext_grs_node_t *n_VProj110_1549 = ext_grs_act_add_node_to_keep(pattern, "VProj110_1549", grs_op_VProj, mode_Bu, 86, n_Vector_Result14_Proj951);
+       ext_grs_node_t *n_Proj935_1550 = ext_grs_act_add_node_to_keep(pattern, "Proj935_1550", grs_op_Proj, mode_M, 7, n_Proj935);
+       ext_grs_node_t *n_Proj740_1551 = ext_grs_act_add_node_to_keep(pattern, "Proj740_1551", grs_op_Proj, mode_M, 8, n_Proj740);
+       ext_grs_node_t *n_Const727_1552 = ext_grs_act_add_node_to_keep(pattern, "Const727_1552", grs_op_Const, mode_Is, 9, n_Const727);
+       ext_grs_node_t *n_MultipleAdd5719_1553 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5719_1553", grs_op_MultipleAdd, mode_P, 10, n_MultipleAdd5719);
+       ext_grs_node_t *n_Load934_1554 = ext_grs_act_add_node_to_keep(pattern, "Load934_1554", grs_op_Load, mode_T, 11, n_Load934);
+       ext_grs_node_t *n_MultipleAdd5717_1555 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5717_1555", grs_op_MultipleAdd, mode_P, 12, n_MultipleAdd5717);
+       ext_grs_node_t *n_Load739_1556 = ext_grs_act_add_node_to_keep(pattern, "Load739_1556", grs_op_Load, mode_T, 13, n_Load739);
+       ext_grs_node_t *n_Const929_1557 = ext_grs_act_add_node_to_keep(pattern, "Const929_1557", grs_op_Const, mode_Is, 14, n_Const929);
+       ext_grs_node_t *n_Load829_1558 = ext_grs_act_add_node_to_keep(pattern, "Load829_1558", grs_op_Load, mode_T, 15, n_Load829);
+       ext_grs_node_t *n_VProj100_1559 = ext_grs_act_add_node_to_keep(pattern, "VProj100_1559", grs_op_VProj, mode_Bu, 87, n_Vector_Result7_Proj846);
+       ext_grs_node_t *n_Proj875_1560 = ext_grs_act_add_node_to_keep(pattern, "Proj875_1560", grs_op_Proj, mode_M, 17, n_Proj875);
+       ext_grs_node_t *n_Const869_1561 = ext_grs_act_add_node_to_keep(pattern, "Const869_1561", grs_op_Const, mode_Is, 18, n_Const869);
+       ext_grs_node_t *n_Arg_0_1562 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1562", grs_op_VectorBase, mode_ANY, 19, n_Arg_0);
+       ext_grs_node_t *n_Const854_1563 = ext_grs_act_add_node_to_keep(pattern, "Const854_1563", grs_op_Const, mode_Is, 20, n_Const854);
+       ext_grs_node_t *n_Load844_1564 = ext_grs_act_add_node_to_keep(pattern, "Load844_1564", grs_op_Load, mode_T, 21, n_Load844);
+       ext_grs_node_t *n_Const824_1565 = ext_grs_act_add_node_to_keep(pattern, "Const824_1565", grs_op_Const, mode_Is, 22, n_Const824);
+       ext_grs_node_t *n_Proj890_1566 = ext_grs_act_add_node_to_keep(pattern, "Proj890_1566", grs_op_Proj, mode_M, 23, n_Proj890);
+       ext_grs_node_t *n_VProj106_1567 = ext_grs_act_add_node_to_keep(pattern, "VProj106_1567", grs_op_VProj, mode_Bu, 88, n_Vector_Result9_Proj876);
+       ext_grs_node_t *n_MultipleAdd5713_1568 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5713_1568", grs_op_MultipleAdd, mode_P, 24, n_MultipleAdd5713);
+       ext_grs_node_t *n_MultipleAdd5715_1569 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5715_1569", grs_op_MultipleAdd, mode_P, 26, n_MultipleAdd5715);
+       ext_grs_node_t *n_Const899_1570 = ext_grs_act_add_node_to_keep(pattern, "Const899_1570", grs_op_Const, mode_Is, 27, n_Const899);
+       ext_grs_node_t *n_Load889_1571 = ext_grs_act_add_node_to_keep(pattern, "Load889_1571", grs_op_Load, mode_T, 28, n_Load889);
+       ext_grs_node_t *n_Proj800_1572 = ext_grs_act_add_node_to_keep(pattern, "Proj800_1572", grs_op_Proj, mode_M, 29, n_Proj800);
+       ext_grs_node_t *n_VProj92_1573 = ext_grs_act_add_node_to_keep(pattern, "VProj92_1573", grs_op_VProj, mode_Bu, 89, n_Vector_Result13_Proj936);
+       ext_grs_node_t *n_MultipleAdd5711_1574 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5711_1574", grs_op_MultipleAdd, mode_P, 31, n_MultipleAdd5711);
+       ext_grs_node_t *n_MultipleAdd5693_1575 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5693_1575", grs_op_MultipleAdd, mode_P, 33, n_MultipleAdd5693);
+       ext_grs_node_t *n_Load949_1576 = ext_grs_act_add_node_to_keep(pattern, "Load949_1576", grs_op_Load, mode_T, 32, n_Load949);
+       ext_grs_node_t *n_Proj785_1577 = ext_grs_act_add_node_to_keep(pattern, "Proj785_1577", grs_op_Proj, mode_M, 35, n_Proj785);
+       ext_grs_node_t *n_MultipleAdd5691_1578 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5691_1578", grs_op_MultipleAdd, mode_P, 34, n_MultipleAdd5691);
+       ext_grs_node_t *n_MultipleAdd5707_1579 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5707_1579", grs_op_MultipleAdd, mode_P, 39, n_MultipleAdd5707);
+       ext_grs_node_t *n_MultipleAdd5697_1580 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5697_1580", grs_op_MultipleAdd, mode_P, 38, n_MultipleAdd5697);
+       ext_grs_node_t *n_Load799_1581 = ext_grs_act_add_node_to_keep(pattern, "Load799_1581", grs_op_Load, mode_T, 36, n_Load799);
+       ext_grs_node_t *n_VProj88_1582 = ext_grs_act_add_node_to_keep(pattern, "VProj88_1582", grs_op_VProj, mode_Bu, 90, n_Vector_Result8_Proj861);
+       ext_grs_node_t *n_VProj114_1583 = ext_grs_act_add_node_to_keep(pattern, "VProj114_1583", grs_op_VProj, mode_Bu, 91, n_Vector_Result6_Proj831);
+       ext_grs_node_t *n_Proj845_1584 = ext_grs_act_add_node_to_keep(pattern, "Proj845_1584", grs_op_Proj, mode_M, 45, n_Proj845);
+       ext_grs_node_t *n_Proj950_1585 = ext_grs_act_add_node_to_keep(pattern, "Proj950_1585", grs_op_Proj, mode_M, 44, n_Proj950);
+       ext_grs_node_t *n_MultipleAdd5695_1586 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5695_1586", grs_op_MultipleAdd, mode_P, 43, n_MultipleAdd5695);
+       ext_grs_node_t *n_MultipleAdd5709_1587 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5709_1587", grs_op_MultipleAdd, mode_P, 41, n_MultipleAdd5709);
+       ext_grs_node_t *n_VProj86_1588 = ext_grs_act_add_node_to_keep(pattern, "VProj86_1588", grs_op_VProj, mode_Bu, 92, n_Vector_Result11_Proj906);
+       ext_grs_node_t *n_VProj96_1589 = ext_grs_act_add_node_to_keep(pattern, "VProj96_1589", grs_op_VProj, mode_Bu, 93, n_Vector_Result5_Proj816);
+       ext_grs_node_t *n_Load904_1590 = ext_grs_act_add_node_to_keep(pattern, "Load904_1590", grs_op_Load, mode_T, 47, n_Load904);
+       ext_grs_node_t *n_Load784_1591 = ext_grs_act_add_node_to_keep(pattern, "Load784_1591", grs_op_Load, mode_T, 48, n_Load784);
+       ext_grs_node_t *n_MultipleAdd5699_1592 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5699_1592", grs_op_MultipleAdd, mode_P, 50, n_MultipleAdd5699);
+       ext_grs_node_t *n_Proj905_1593 = ext_grs_act_add_node_to_keep(pattern, "Proj905_1593", grs_op_Proj, mode_M, 49, n_Proj905);
+       ext_grs_node_t *n_Const794_1594 = ext_grs_act_add_node_to_keep(pattern, "Const794_1594", grs_op_Const, mode_Is, 51, n_Const794);
+       ext_grs_node_t *n_Const914_1595 = ext_grs_act_add_node_to_keep(pattern, "Const914_1595", grs_op_Const, mode_Is, 52, n_Const914);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 94);
+       ext_grs_node_t *n_Load859_1596 = ext_grs_act_add_node_to_keep(pattern, "Load859_1596", grs_op_Load, mode_T, 53, n_Load859);
+       ext_grs_node_t *n_Const944_1597 = ext_grs_act_add_node_to_keep(pattern, "Const944_1597", grs_op_Const, mode_Is, 54, n_Const944);
+       ext_grs_node_t *n_Proj860_1598 = ext_grs_act_add_node_to_keep(pattern, "Proj860_1598", grs_op_Proj, mode_M, 55, n_Proj860);
+       ext_grs_node_t *n_IR_node5724_1599 = ext_grs_act_add_node_to_keep(pattern, "IR_node5724_1599", grs_op_IR_node, mode_ANY, 56, n_IR_node5724);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 95);
+       ext_grs_node_t *n_MultipleAdd5701_1600 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5701_1600", grs_op_MultipleAdd, mode_P, 57, n_MultipleAdd5701);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 96);
+       ext_grs_node_t *n_MultipleAdd5705_1601 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5705_1601", grs_op_MultipleAdd, mode_P, 58, n_MultipleAdd5705);
+       ext_grs_node_t *n_MultipleAdd5703_1602 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5703_1602", grs_op_MultipleAdd, mode_P, 60, n_MultipleAdd5703);
+       ext_grs_node_t *n_IR_node5725_1603 = ext_grs_act_add_node_to_keep(pattern, "IR_node5725_1603", grs_op_IR_node, mode_ANY, 59, n_IR_node5725);
+       ext_grs_node_t *n_VProj94_1604 = ext_grs_act_add_node_to_keep(pattern, "VProj94_1604", grs_op_VProj, mode_Bu, 97, n_Vector_Result4_Proj801);
+       ext_grs_node_t *n_VProj84_1605 = ext_grs_act_add_node_to_keep(pattern, "VProj84_1605", grs_op_VProj, mode_Bu, 98, n_Vector_Result0_Proj741);
+       ext_grs_node_t *n_Proj815_1606 = ext_grs_act_add_node_to_keep(pattern, "Proj815_1606", grs_op_Proj, mode_M, 63, n_Proj815);
+       ext_grs_node_t *n_Proj755_1607 = ext_grs_act_add_node_to_keep(pattern, "Proj755_1607", grs_op_Proj, mode_M, 64, n_Proj755);
+       ext_grs_node_t *n_Load814_1608 = ext_grs_act_add_node_to_keep(pattern, "Load814_1608", grs_op_Load, mode_T, 65, n_Load814);
+       ext_grs_node_t *n_VProj108_1609 = ext_grs_act_add_node_to_keep(pattern, "VProj108_1609", grs_op_VProj, mode_Bu, 99, n_Vector_Result3_Proj786);
+       ext_grs_node_t *n_Load754_1610 = ext_grs_act_add_node_to_keep(pattern, "Load754_1610", grs_op_Load, mode_T, 67, n_Load754);
+       ext_grs_node_t *n_Bad84 = ext_grs_act_add_node(pattern, "Bad84", grs_op_Bad, mode_ANY, 100);
+       ext_grs_node_t *n_Const809_1611 = ext_grs_act_add_node_to_keep(pattern, "Const809_1611", grs_op_Const, mode_Is, 68, n_Const809);
+       ext_grs_node_t *n_Const779_1612 = ext_grs_act_add_node_to_keep(pattern, "Const779_1612", grs_op_Const, mode_Is, 69, n_Const779);
+       ext_grs_node_t *n_Vector_op_Block_1613 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1613", grs_op_Block, mode_BB, 70, n_Vector_op_Block);
+       ext_grs_node_t *n_Load919_1614 = ext_grs_act_add_node_to_keep(pattern, "Load919_1614", grs_op_Load, mode_T, 72, n_Load919);
+       ext_grs_node_t *n_Load964_1615 = ext_grs_act_add_node_to_keep(pattern, "Load964_1615", grs_op_Load, mode_T, 71, n_Load964);
+       ext_grs_node_t *n_VProj98_1616 = ext_grs_act_add_node_to_keep(pattern, "VProj98_1616", grs_op_VProj, mode_Bu, 101, n_Vector_Result10_Proj891);
+       ext_grs_node_t *n_Const735_1617 = ext_grs_act_add_node_to_keep(pattern, "Const735_1617", grs_op_Const, mode_Is, 74, n_Const735);
+       ext_grs_node_t *n_VProj90_1618 = ext_grs_act_add_node_to_keep(pattern, "VProj90_1618", grs_op_VProj, mode_Bu, 102, n_Vector_Result2_Proj771);
+       ext_grs_node_t *n_Const731_1619 = ext_grs_act_add_node_to_keep(pattern, "Const731_1619", grs_op_Const, mode_Is, 76, n_Const731);
+       ext_grs_node_t *n_Proj965_1620 = ext_grs_act_add_node_to_keep(pattern, "Proj965_1620", grs_op_Proj, mode_M, 79, n_Proj965);
+       ext_grs_node_t *n_Proj770_1621 = ext_grs_act_add_node_to_keep(pattern, "Proj770_1621", grs_op_Proj, mode_M, 78, n_Proj770);
+       ext_grs_node_t *n_Proj830_1622 = ext_grs_act_add_node_to_keep(pattern, "Proj830_1622", grs_op_Proj, mode_M, 77, n_Proj830);
+       ext_grs_node_t *n_Load769_1623 = ext_grs_act_add_node_to_keep(pattern, "Load769_1623", grs_op_Load, mode_T, 80, n_Load769);
+       ext_grs_node_t *n_VProj112_1624 = ext_grs_act_add_node_to_keep(pattern, "VProj112_1624", grs_op_VProj, mode_Bu, 103, n_Vector_Result15_Proj966);
+       ext_grs_node_t *n_Proj920_1625 = ext_grs_act_add_node_to_keep(pattern, "Proj920_1625", grs_op_Proj, mode_M, 82, n_Proj920);
+       ext_grs_node_t *n_Const839_1626 = ext_grs_act_add_node_to_keep(pattern, "Const839_1626", grs_op_Const, mode_Is, 83, n_Const839);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_147_1627 = ext_grs_act_add_edge_to_keep(pattern, "pos1_147_1627", 0, n_Load859_1596, n_Proj860_1598, 0, e_pos1_147);
+       ext_grs_edge_t *e_pos1_149_1628 = ext_grs_act_add_edge_to_keep(pattern, "pos1_149_1628", 0, n_Load784_1591, n_Proj785_1577, 1, e_pos1_149);
+       ext_grs_edge_t *e_pos1_140_1629 = ext_grs_act_add_edge_to_keep(pattern, "pos1_140_1629", 0, n_Load964_1615, n_Proj965_1620, 3, e_pos1_140);
+       ext_grs_edge_t *e_e131_1630 = ext_grs_act_add_edge_to_keep(pattern, "e131_1630", ext_grs_NO_EDGE_POS, n_Const914_1595, n_MultipleAdd5697_1580, 4, e_e131);
+       ext_grs_edge_t *e_e133_1631 = ext_grs_act_add_edge_to_keep(pattern, "e133_1631", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5697_1580, 5, e_e133);
+       ext_grs_edge_t *e_e132_1632 = ext_grs_act_add_edge_to_keep(pattern, "e132_1632", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5697_1580, 6, e_e132);
+       ext_grs_edge_t *e_e135_1633 = ext_grs_act_add_edge_to_keep(pattern, "e135_1633", ext_grs_NO_EDGE_POS, n_Const727_1552, n_MultipleAdd5723_1548, 7, e_e135);
+       ext_grs_edge_t *e_e134_1634 = ext_grs_act_add_edge_to_keep(pattern, "e134_1634", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5697_1580, 8, e_e134);
+       ext_grs_edge_t *e_e137_1635 = ext_grs_act_add_edge_to_keep(pattern, "e137_1635", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5723_1548, 9, e_e137);
+       ext_grs_edge_t *e_e136_1636 = ext_grs_act_add_edge_to_keep(pattern, "e136_1636", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5723_1548, 10, e_e136);
+       ext_grs_edge_t *e_pos2_171_1637 = ext_grs_act_add_edge_to_keep(pattern, "pos2_171_1637", 1, n_MultipleAdd5697_1580, n_Load919_1614, 11, e_pos2_171);
+       ext_grs_edge_t *e_e138_1638 = ext_grs_act_add_edge_to_keep(pattern, "e138_1638", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5723_1548, 12, e_e138);
+       ext_grs_edge_t *e_pos2_175_1639 = ext_grs_act_add_edge_to_keep(pattern, "pos2_175_1639", 1, n_MultipleAdd5703_1602, n_Load874_1545, 13, e_pos2_175);
+       ext_grs_edge_t *e_pos1_130_1640 = ext_grs_act_add_edge_to_keep(pattern, "pos1_130_1640", 0, n_Load769_1623, n_Proj770_1621, 15, e_pos1_130);
+       ext_grs_edge_t *e_e120_1641 = ext_grs_act_add_edge_to_keep(pattern, "e120_1641", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5695_1586, 16, e_e120);
+       ext_grs_edge_t *e_e121_1642 = ext_grs_act_add_edge_to_keep(pattern, "e121_1642", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5695_1586, 18, e_e121);
+       ext_grs_edge_t *e_e128_1643 = ext_grs_act_add_edge_to_keep(pattern, "e128_1643", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5705_1601, 19, e_e128);
+       ext_grs_edge_t *e_e127_1644 = ext_grs_act_add_edge_to_keep(pattern, "e127_1644", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5705_1601, 20, e_e127);
+       ext_grs_edge_t *e_pos2_181_1645 = ext_grs_act_add_edge_to_keep(pattern, "pos2_181_1645", 1, n_MultipleAdd5715_1569, n_Load784_1591, 21, e_pos2_181);
+       ext_grs_edge_t *e_e126_1646 = ext_grs_act_add_edge_to_keep(pattern, "e126_1646", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5705_1601, 22, e_e126);
+       ext_grs_edge_t *e_e125_1647 = ext_grs_act_add_edge_to_keep(pattern, "e125_1647", ext_grs_NO_EDGE_POS, n_Const854_1563, n_MultipleAdd5705_1601, 23, e_e125);
+       ext_grs_edge_t *e_pos2_184_1648 = ext_grs_act_add_edge_to_keep(pattern, "pos2_184_1648", 1, n_MultipleAdd5693_1575, n_Load949_1576, 24, e_pos2_184);
+       ext_grs_edge_t *e_pos1_162_1649 = ext_grs_act_add_edge_to_keep(pattern, "pos1_162_1649", 0, n_Load799_1581, n_Proj800_1572, 27, e_pos1_162);
+       ext_grs_edge_t *e_pos1_161_1650 = ext_grs_act_add_edge_to_keep(pattern, "pos1_161_1650", 0, n_Load874_1545, n_Proj875_1560, 28, e_pos1_161);
+       ext_grs_edge_t *e_e119_1651 = ext_grs_act_add_edge_to_keep(pattern, "e119_1651", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5695_1586, 30, e_e119);
+       ext_grs_edge_t *e_pos2_195_1652 = ext_grs_act_add_edge_to_keep(pattern, "pos2_195_1652", 1, n_MultipleAdd5691_1578, n_Load964_1615, 29, e_pos2_195);
+       ext_grs_edge_t *e_e118_1653 = ext_grs_act_add_edge_to_keep(pattern, "e118_1653", ext_grs_NO_EDGE_POS, n_Const929_1557, n_MultipleAdd5695_1586, 31, e_e118);
+       ext_grs_edge_t *e_pos0_203_1654 = ext_grs_act_add_edge(pattern, "pos0_203_1654", -1, n_Vector_op_Block_1613, n_Vector_op_ProjM, 113);
+       ext_grs_edge_t *e_e115_1655 = ext_grs_act_add_edge_to_keep(pattern, "e115_1655", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5719_1553, 32, e_e115);
+       ext_grs_edge_t *e_e114_1656 = ext_grs_act_add_edge_to_keep(pattern, "e114_1656", ext_grs_NO_EDGE_POS, n_Const735_1617, n_MultipleAdd5719_1553, 33, e_e114);
+       ext_grs_edge_t *e_e117_1657 = ext_grs_act_add_edge_to_keep(pattern, "e117_1657", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5719_1553, 34, e_e117);
+       ext_grs_edge_t *e_e116_1658 = ext_grs_act_add_edge_to_keep(pattern, "e116_1658", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5719_1553, 35, e_e116);
+       ext_grs_edge_t *e_e101_1659 = ext_grs_act_add_edge_to_keep(pattern, "e101_1659", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5693_1575, 38, e_e101);
+       ext_grs_edge_t *e_e100_1660 = ext_grs_act_add_edge_to_keep(pattern, "e100_1660", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5693_1575, 39, e_e100);
+       ext_grs_edge_t *e_e108_1661 = ext_grs_act_add_edge_to_keep(pattern, "e108_1661", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5703_1602, 40, e_e108);
+       ext_grs_edge_t *e_e107_1662 = ext_grs_act_add_edge_to_keep(pattern, "e107_1662", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5703_1602, 41, e_e107);
+       ext_grs_edge_t *e_e106_1663 = ext_grs_act_add_edge_to_keep(pattern, "e106_1663", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5703_1602, 42, e_e106);
+       ext_grs_edge_t *e_e105_1664 = ext_grs_act_add_edge_to_keep(pattern, "e105_1664", ext_grs_NO_EDGE_POS, n_Const869_1561, n_MultipleAdd5703_1602, 43, e_e105);
+       ext_grs_edge_t *e_pos1_180_1665 = ext_grs_act_add_edge_to_keep(pattern, "pos1_180_1665", 0, n_Load904_1590, n_Proj905_1593, 46, e_pos1_180);
+       ext_grs_edge_t *e_pos1_172_1666 = ext_grs_act_add_edge_to_keep(pattern, "pos1_172_1666", 0, n_Load889_1571, n_Proj890_1566, 47, e_pos1_172);
+       ext_grs_edge_t *e_e98_1667 = ext_grs_act_add_edge_to_keep(pattern, "e98_1667", ext_grs_NO_EDGE_POS, n_Const944_1597, n_MultipleAdd5693_1575, 53, e_e98);
+       ext_grs_edge_t *e_pos2_97_1668 = ext_grs_act_add_edge_to_keep(pattern, "pos2_97_1668", 1, n_MultipleAdd5723_1548, n_Load739_1556, 52, e_pos2_97);
+       ext_grs_edge_t *e_pos1_91_1669 = ext_grs_act_add_edge_to_keep(pattern, "pos1_91_1669", 0, n_Load814_1608, n_Proj815_1606, 51, e_pos1_91);
+       ext_grs_edge_t *e_pos1_92_1670 = ext_grs_act_add_edge_to_keep(pattern, "pos1_92_1670", 0, n_Load739_1556, n_Proj740_1551, 55, e_pos1_92);
+       ext_grs_edge_t *e_e95_1671 = ext_grs_act_add_edge_to_keep(pattern, "e95_1671", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5717_1555, 54, e_e95);
+       ext_grs_edge_t *e_e96_1672 = ext_grs_act_add_edge_to_keep(pattern, "e96_1672", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5717_1555, 56, e_e96);
+       ext_grs_edge_t *e_e99_1673 = ext_grs_act_add_edge_to_keep(pattern, "e99_1673", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5693_1575, 57, e_e99);
+       ext_grs_edge_t *e_pos0_197_1674 = ext_grs_act_add_edge(pattern, "pos0_197_1674", -1, n_Vector_op_Block_1613, n_Vector_op, 114);
+       ext_grs_edge_t *e_pos0_198_1675 = ext_grs_act_add_edge(pattern, "pos0_198_1675", -1, n_Vector_op_Block_1613, n_Vector_op_ProjData, 115);
+       ext_grs_edge_t *e_e93_1676 = ext_grs_act_add_edge_to_keep(pattern, "e93_1676", ext_grs_NO_EDGE_POS, n_Const764_1543, n_MultipleAdd5717_1555, 58, e_e93);
+       ext_grs_edge_t *e_e94_1677 = ext_grs_act_add_edge_to_keep(pattern, "e94_1677", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5717_1555, 59, e_e94);
+       ext_grs_edge_t *e_pos0_194_1678 = ext_grs_act_add_edge_to_keep(pattern, "pos0_194_1678", -1, n_Vector_op_Block_1613, n_Load964_1615, 60, e_pos0_194);
+       ext_grs_edge_t *e_pos1_196_1679 = ext_grs_act_add_edge_to_keep(pattern, "pos1_196_1679", 0, n_Load919_1614, n_Proj920_1625, 61, e_pos1_196);
+       ext_grs_edge_t *e_pos1_199_1680 = ext_grs_act_add_edge(pattern, "pos1_199_1680", 0, n_Vector_op, n_Vector_op_ProjData, 116);
+       ext_grs_edge_t *e_pos2_89_1681 = ext_grs_act_add_edge_to_keep(pattern, "pos2_89_1681", 1, n_MultipleAdd5709_1587, n_Load829_1558, 63, e_pos2_89);
+       ext_grs_edge_t *e_e186_1682 = ext_grs_act_add_edge_to_keep(pattern, "e186_1682", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5715_1569, 64, e_e186);
+       ext_grs_edge_t *e_e185_1683 = ext_grs_act_add_edge_to_keep(pattern, "e185_1683", ext_grs_NO_EDGE_POS, n_Const779_1612, n_MultipleAdd5715_1569, 65, e_e185);
+       ext_grs_edge_t *e_e188_1684 = ext_grs_act_add_edge_to_keep(pattern, "e188_1684", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5715_1569, 66, e_e188);
+       ext_grs_edge_t *e_e187_1685 = ext_grs_act_add_edge_to_keep(pattern, "e187_1685", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5715_1569, 67, e_e187);
+       ext_grs_edge_t *e_e189_1686 = ext_grs_act_add_edge_to_keep(pattern, "e189_1686", ext_grs_NO_EDGE_POS, n_Const959_1544, n_MultipleAdd5691_1578, 68, e_e189);
+       ext_grs_edge_t *e_e190_1687 = ext_grs_act_add_edge_to_keep(pattern, "e190_1687", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5691_1578, 69, e_e190);
+       ext_grs_edge_t *e_e191_1688 = ext_grs_act_add_edge_to_keep(pattern, "e191_1688", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5691_1578, 70, e_e191);
+       ext_grs_edge_t *e_e192_1689 = ext_grs_act_add_edge_to_keep(pattern, "e192_1689", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5691_1578, 71, e_e192);
+       ext_grs_edge_t *e_pos2_201_1690 = ext_grs_act_add_edge(pattern, "pos2_201_1690", 1, n_Bad84, n_Vector_op, 117);
+       ext_grs_edge_t *e_pos2_103_1691 = ext_grs_act_add_edge_to_keep(pattern, "pos2_103_1691", 1, n_MultipleAdd5699_1592, n_Load904_1590, 72, e_pos2_103);
+       ext_grs_edge_t *e_e87_1692 = ext_grs_act_add_edge_to_keep(pattern, "e87_1692", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5701_1600, 73, e_e87);
+       ext_grs_edge_t *e_e86_1693 = ext_grs_act_add_edge_to_keep(pattern, "e86_1693", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5701_1600, 74, e_e86);
+       ext_grs_edge_t *e_e85_1694 = ext_grs_act_add_edge_to_keep(pattern, "e85_1694", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5701_1600, 75, e_e85);
+       ext_grs_edge_t *e_e84_1695 = ext_grs_act_add_edge_to_keep(pattern, "e84_1695", ext_grs_NO_EDGE_POS, n_Const731_1619, n_MultipleAdd5701_1600, 76, e_e84);
+       ext_grs_edge_t *e_pos2_112_1696 = ext_grs_act_add_edge_to_keep(pattern, "pos2_112_1696", 1, n_MultipleAdd5705_1601, n_Load859_1596, 77, e_pos2_112);
+       ext_grs_edge_t *e_pos1_212_1697 = ext_grs_act_add_edge(pattern, "pos1_212_1697", 0, n_Vector_op_ProjData, n_VProj100_1559, 118);
+       ext_grs_edge_t *e_pos1_213_1698 = ext_grs_act_add_edge(pattern, "pos1_213_1698", 0, n_Vector_op_ProjData, n_VProj102_1546, 119);
+       ext_grs_edge_t *e_pos1_210_1699 = ext_grs_act_add_edge(pattern, "pos1_210_1699", 0, n_Vector_op_ProjData, n_VProj96_1589, 120);
+       ext_grs_edge_t *e_pos1_211_1700 = ext_grs_act_add_edge(pattern, "pos1_211_1700", 0, n_Vector_op_ProjData, n_VProj98_1616, 121);
+       ext_grs_edge_t *e_pos1_216_1701 = ext_grs_act_add_edge(pattern, "pos1_216_1701", 0, n_Vector_op_ProjData, n_VProj108_1609, 122);
+       ext_grs_edge_t *e_pos1_217_1702 = ext_grs_act_add_edge(pattern, "pos1_217_1702", 0, n_Vector_op_ProjData, n_VProj110_1549, 123);
+       ext_grs_edge_t *e_pos1_214_1703 = ext_grs_act_add_edge(pattern, "pos1_214_1703", 0, n_Vector_op_ProjData, n_VProj104_1547, 124);
+       ext_grs_edge_t *e_pos2_124_1704 = ext_grs_act_add_edge_to_keep(pattern, "pos2_124_1704", 1, n_MultipleAdd5695_1586, n_Load934_1554, 78, e_pos2_124);
+       ext_grs_edge_t *e_pos1_215_1705 = ext_grs_act_add_edge(pattern, "pos1_215_1705", 0, n_Vector_op_ProjData, n_VProj106_1567, 125);
+       ext_grs_edge_t *e_pos2_123_1706 = ext_grs_act_add_edge_to_keep(pattern, "pos2_123_1706", 1, n_MultipleAdd5717_1555, n_Load769_1623, 79, e_pos2_123);
+       ext_grs_edge_t *e_pos1_219_1707 = ext_grs_act_add_edge(pattern, "pos1_219_1707", 0, n_Vector_op_ProjData, n_VProj114_1583, 126);
+       ext_grs_edge_t *e_pos1_218_1708 = ext_grs_act_add_edge(pattern, "pos1_218_1708", 0, n_Vector_op_ProjData, n_VProj112_1624, 127);
+       ext_grs_edge_t *e_pos1_109_1709 = ext_grs_act_add_edge_to_keep(pattern, "pos1_109_1709", 0, n_Load829_1558, n_Proj830_1622, 80, e_pos1_109);
+       ext_grs_edge_t *e_e142_1710 = ext_grs_act_add_edge_to_keep(pattern, "e142_1710", ext_grs_NO_EDGE_POS, n_Const839_1626, n_MultipleAdd5707_1579, 81, e_e142);
+       ext_grs_edge_t *e_e143_1711 = ext_grs_act_add_edge_to_keep(pattern, "e143_1711", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5707_1579, 82, e_e143);
+       ext_grs_edge_t *e_e144_1712 = ext_grs_act_add_edge_to_keep(pattern, "e144_1712", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5707_1579, 83, e_e144);
+       ext_grs_edge_t *e_e145_1713 = ext_grs_act_add_edge_to_keep(pattern, "e145_1713", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5707_1579, 84, e_e145);
+       ext_grs_edge_t *e_pos1_204_1714 = ext_grs_act_add_edge(pattern, "pos1_204_1714", 0, n_Vector_op_ProjData, n_VProj84_1605, 128);
+       ext_grs_edge_t *e_pos1_206_1715 = ext_grs_act_add_edge(pattern, "pos1_206_1715", 0, n_Vector_op_ProjData, n_VProj88_1582, 129);
+       ext_grs_edge_t *e_pos1_205_1716 = ext_grs_act_add_edge(pattern, "pos1_205_1716", 0, n_Vector_op_ProjData, n_VProj86_1588, 130);
+       ext_grs_edge_t *e_pos1_200_1717 = ext_grs_act_add_edge(pattern, "pos1_200_1717", 0, n_MultipleAdd5723_1548, n_Vector_op, 131);
+       ext_grs_edge_t *e_pos1_202_1718 = ext_grs_act_add_edge(pattern, "pos1_202_1718", 0, n_Vector_op, n_Vector_op_ProjM, 132);
+       ext_grs_edge_t *e_pos1_207_1719 = ext_grs_act_add_edge(pattern, "pos1_207_1719", 0, n_Vector_op_ProjData, n_VProj90_1618, 133);
+       ext_grs_edge_t *e_pos1_208_1720 = ext_grs_act_add_edge(pattern, "pos1_208_1720", 0, n_Vector_op_ProjData, n_VProj92_1573, 134);
+       ext_grs_edge_t *e_pos1_209_1721 = ext_grs_act_add_edge(pattern, "pos1_209_1721", 0, n_Vector_op_ProjData, n_VProj94_1604, 135);
+       ext_grs_edge_t *e_pos1_102_1722 = ext_grs_act_add_edge_to_keep(pattern, "pos1_102_1722", 0, n_Load934_1554, n_Proj935_1550, 85, e_pos1_102);
+       ext_grs_edge_t *e_e152_1723 = ext_grs_act_add_edge_to_keep(pattern, "e152_1723", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5699_1592, 87, e_e152);
+       ext_grs_edge_t *e_e153_1724 = ext_grs_act_add_edge_to_keep(pattern, "e153_1724", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5699_1592, 88, e_e153);
+       ext_grs_edge_t *e_e151_1725 = ext_grs_act_add_edge_to_keep(pattern, "e151_1725", ext_grs_NO_EDGE_POS, n_Const899_1570, n_MultipleAdd5699_1592, 89, e_e151);
+       ext_grs_edge_t *e_e157_1726 = ext_grs_act_add_edge_to_keep(pattern, "e157_1726", ext_grs_NO_EDGE_POS, n_Const824_1565, n_MultipleAdd5709_1587, 90, e_e157);
+       ext_grs_edge_t *e_e154_1727 = ext_grs_act_add_edge_to_keep(pattern, "e154_1727", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5699_1592, 91, e_e154);
+       ext_grs_edge_t *e_e158_1728 = ext_grs_act_add_edge_to_keep(pattern, "e158_1728", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5709_1587, 92, e_e158);
+       ext_grs_edge_t *e_pos2_146_1729 = ext_grs_act_add_edge_to_keep(pattern, "pos2_146_1729", 1, n_MultipleAdd5713_1568, n_Load799_1581, 93, e_pos2_146);
+       ext_grs_edge_t *e_e159_1730 = ext_grs_act_add_edge_to_keep(pattern, "e159_1730", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5709_1587, 94, e_e159);
+       ext_grs_edge_t *e_pos2_148_1731 = ext_grs_act_add_edge_to_keep(pattern, "pos2_148_1731", 1, n_MultipleAdd5711_1574, n_Load814_1608, 95, e_pos2_148);
+       ext_grs_edge_t *e_e160_1732 = ext_grs_act_add_edge_to_keep(pattern, "e160_1732", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5709_1587, 96, e_e160);
+       ext_grs_edge_t *e_e167_1733 = ext_grs_act_add_edge_to_keep(pattern, "e167_1733", ext_grs_NO_EDGE_POS, n_Const809_1611, n_MultipleAdd5711_1574, 97, e_e167);
+       ext_grs_edge_t *e_e168_1734 = ext_grs_act_add_edge_to_keep(pattern, "e168_1734", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5711_1574, 98, e_e168);
+       ext_grs_edge_t *e_e169_1735 = ext_grs_act_add_edge_to_keep(pattern, "e169_1735", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5711_1574, 99, e_e169);
+       ext_grs_edge_t *e_pos2_155_1736 = ext_grs_act_add_edge_to_keep(pattern, "pos2_155_1736", 1, n_MultipleAdd5701_1600, n_Load889_1571, 100, e_pos2_155);
+       ext_grs_edge_t *e_pos1_129_1737 = ext_grs_act_add_edge_to_keep(pattern, "pos1_129_1737", 0, n_Load844_1564, n_Proj845_1584, 101, e_pos1_129);
+       ext_grs_edge_t *e_e170_1738 = ext_grs_act_add_edge_to_keep(pattern, "e170_1738", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5711_1574, 102, e_e170);
+       ext_grs_edge_t *e_pos1_122_1739 = ext_grs_act_add_edge_to_keep(pattern, "pos1_122_1739", 0, n_Load949_1576, n_Proj950_1585, 103, e_pos1_122);
+       ext_grs_edge_t *e_e178_1740 = ext_grs_act_add_edge_to_keep(pattern, "e178_1740", ext_grs_NO_EDGE_POS, n_IR_node5724_1599, n_MultipleAdd5713_1568, 104, e_e178);
+       ext_grs_edge_t *e_e179_1741 = ext_grs_act_add_edge_to_keep(pattern, "e179_1741", ext_grs_NO_EDGE_POS, n_IR_node5725_1603, n_MultipleAdd5713_1568, 105, e_e179);
+       ext_grs_edge_t *e_e176_1742 = ext_grs_act_add_edge_to_keep(pattern, "e176_1742", ext_grs_NO_EDGE_POS, n_Const794_1594, n_MultipleAdd5713_1568, 106, e_e176);
+       ext_grs_edge_t *e_e177_1743 = ext_grs_act_add_edge_to_keep(pattern, "e177_1743", ext_grs_NO_EDGE_POS, n_Arg_0_1562, n_MultipleAdd5713_1568, 108, e_e177);
+       ext_grs_edge_t *e_pos2_164_1744 = ext_grs_act_add_edge_to_keep(pattern, "pos2_164_1744", 1, n_MultipleAdd5707_1579, n_Load844_1564, 107, e_pos2_164);
+       ext_grs_edge_t *e_pos2_166_1745 = ext_grs_act_add_edge_to_keep(pattern, "pos2_166_1745", 1, n_MultipleAdd5719_1553, n_Load754_1610, 109, e_pos2_166);
+       ext_grs_edge_t *e_pos1_110_1746 = ext_grs_act_add_edge_to_keep(pattern, "pos1_110_1746", 0, n_Load754_1610, n_Proj755_1607, 110, e_pos1_110);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36507);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36510);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36513);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36516);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36519);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36522);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36525);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36528);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36531);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36534);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36537);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36540);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36543);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36546);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36549);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36552);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36555);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_36558);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vload_16b_variant2 */
+
+
+/* functions for evaluation of conditions of action vload_4f_32_variant0 */
+static int grs_cond_func_31130(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[6/* Const603 */])) == 12;
+}
+static int grs_cond_func_31133(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[2/* Const588 */])) == 8;
+}
+static int grs_cond_func_31136(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[5/* MultipleAdd5687 */]) == 2;
+}
+static int grs_cond_func_31139(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[1/* Proj561 */]) == 0;
+}
+static int grs_cond_func_31142(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[12/* Proj576 */]) == 0;
+}
+static int grs_cond_func_31145(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Vector_Result1_Proj577 */]) == 3;
+}
+static int grs_cond_func_31148(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[10/* Proj591 */]) == 0;
+}
+static int grs_cond_func_31151(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[0/* Proj606 */]) == 0;
+}
+static int grs_cond_func_31154(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[17/* Const556 */])) == 4;
+}
+static int grs_cond_func_31157(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[20/* MultipleAdd5679 */]) == 2;
+}
+static int grs_cond_func_31160(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[4/* Vector_Result0_Proj562 */]) == 3;
+}
+static int grs_cond_func_31163(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[8/* MultipleAdd5681 */]) == 2;
+}
+static int grs_cond_func_31166(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[18/* Vector_Result2_Proj592 */]) == 3;
+}
+static int grs_cond_func_31169(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[13/* Vector_Result3_Proj607 */]) == 3;
+}
+static int grs_cond_func_31172(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[7/* MultipleAdd5683 */]) == 2;
+}
+static int grs_cond_func_31175(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[14/* Const552 */])) == 0;
+}
+
+static void *grs_eval_out_func_31316(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[23/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_31319(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[22/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_31322(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[27/* VProj22 */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_31325(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[24/* VProj24 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_31328(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[28/* VProj26 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_31331(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[26/* VProj28 */], 3);
+  return(NULL);
+}
+/* functions for building the pattern of action vload_4f_32_variant0 */
+static _inline ext_grs_action_t *grs_action_vload_4f_32_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vload_4f_32_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Proj606 = ext_grs_act_add_node(pattern, "Proj606", grs_op_Proj, mode_M, 0);
+    ext_grs_node_t *n_Proj561 = ext_grs_act_add_node(pattern, "Proj561", grs_op_Proj, mode_M, 1);
+    ext_grs_node_t *n_Const588 = ext_grs_act_add_node(pattern, "Const588", grs_op_Const, mode_Is, 2);
+    ext_grs_node_t *n_Load560 = ext_grs_act_add_node(pattern, "Load560", grs_op_Load, mode_T, 3);
+    ext_grs_node_t *n_Vector_Result0_Proj562 = ext_grs_act_add_node(pattern, "Vector_Result0_Proj562", grs_op_Proj, mode_F, 4);
+    ext_grs_node_t *n_MultipleAdd5687 = ext_grs_act_add_node(pattern, "MultipleAdd5687", grs_op_MultipleAdd, mode_P, 5);
+    ext_grs_node_t *n_Const603 = ext_grs_act_add_node(pattern, "Const603", grs_op_Const, mode_Is, 6);
+    ext_grs_node_t *n_MultipleAdd5683 = ext_grs_act_add_node(pattern, "MultipleAdd5683", grs_op_MultipleAdd, mode_P, 7);
+    ext_grs_node_t *n_MultipleAdd5681 = ext_grs_act_add_node(pattern, "MultipleAdd5681", grs_op_MultipleAdd, mode_P, 8);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 9);
+    ext_grs_node_t *n_Proj591 = ext_grs_act_add_node(pattern, "Proj591", grs_op_Proj, mode_M, 10);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 11);
+    ext_grs_node_t *n_Proj576 = ext_grs_act_add_node(pattern, "Proj576", grs_op_Proj, mode_M, 12);
+    ext_grs_node_t *n_Vector_Result3_Proj607 = ext_grs_act_add_node(pattern, "Vector_Result3_Proj607", grs_op_Proj, mode_F, 13);
+    ext_grs_node_t *n_Const552 = ext_grs_act_add_node(pattern, "Const552", grs_op_Const, mode_Is, 14);
+    ext_grs_node_t *n_Vector_Result1_Proj577 = ext_grs_act_add_node(pattern, "Vector_Result1_Proj577", grs_op_Proj, mode_F, 15);
+    ext_grs_node_t *n_Load575 = ext_grs_act_add_node(pattern, "Load575", grs_op_Load, mode_T, 16);
+    ext_grs_node_t *n_Const556 = ext_grs_act_add_node(pattern, "Const556", grs_op_Const, mode_Is, 17);
+    ext_grs_node_t *n_Vector_Result2_Proj592 = ext_grs_act_add_node(pattern, "Vector_Result2_Proj592", grs_op_Proj, mode_F, 18);
+    ext_grs_node_t *n_Load605 = ext_grs_act_add_node(pattern, "Load605", grs_op_Load, mode_T, 19);
+    ext_grs_node_t *n_MultipleAdd5679 = ext_grs_act_add_node(pattern, "MultipleAdd5679", grs_op_MultipleAdd, mode_P, 20);
+    ext_grs_node_t *n_Load590 = ext_grs_act_add_node(pattern, "Load590", grs_op_Load, mode_T, 21);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e34 = ext_grs_act_add_edge(pattern, "e34", ext_grs_NO_EDGE_POS, n_Const588, n_MultipleAdd5681, 0);
+    ext_grs_edge_t *e_e35 = ext_grs_act_add_edge(pattern, "e35", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5681, 1);
+    ext_grs_edge_t *e_e30 = ext_grs_act_add_edge(pattern, "e30", ext_grs_NO_EDGE_POS, n_Const603, n_MultipleAdd5679, 2);
+    ext_grs_edge_t *e_e31 = ext_grs_act_add_edge(pattern, "e31", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5679, 3);
+    ext_grs_edge_t *e_pos1_36 = ext_grs_act_add_edge(pattern, "pos1_36", 0, n_Load590, n_Vector_Result2_Proj592, 4);
+    ext_grs_edge_t *e_pos1_37 = ext_grs_act_add_edge(pattern, "pos1_37", 0, n_Load605, n_Vector_Result3_Proj607, 5);
+    ext_grs_edge_t *e_pos1_32 = ext_grs_act_add_edge(pattern, "pos1_32", 0, n_Load560, n_Vector_Result0_Proj562, 6);
+    ext_grs_edge_t *e_pos2_33 = ext_grs_act_add_edge(pattern, "pos2_33", 1, n_MultipleAdd5687, n_Load560, 7);
+    ext_grs_edge_t *e_pos2_38 = ext_grs_act_add_edge(pattern, "pos2_38", 1, n_MultipleAdd5681, n_Load590, 8);
+    ext_grs_edge_t *e_e39 = ext_grs_act_add_edge(pattern, "e39", ext_grs_NO_EDGE_POS, n_Const556, n_MultipleAdd5683, 9);
+    ext_grs_edge_t *e_pos0_41 = ext_grs_act_add_edge(pattern, "pos0_41", -1, n_Vector_op_Block, n_Load605, 10);
+    ext_grs_edge_t *e_e24 = ext_grs_act_add_edge(pattern, "e24", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5687, 11);
+    ext_grs_edge_t *e_e40 = ext_grs_act_add_edge(pattern, "e40", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5683, 12);
+    ext_grs_edge_t *e_e23 = ext_grs_act_add_edge(pattern, "e23", ext_grs_NO_EDGE_POS, n_Const552, n_MultipleAdd5687, 13);
+    ext_grs_edge_t *e_pos1_22 = ext_grs_act_add_edge(pattern, "pos1_22", 0, n_Load560, n_Proj561, 14);
+    ext_grs_edge_t *e_pos1_25 = ext_grs_act_add_edge(pattern, "pos1_25", 0, n_Load575, n_Proj576, 15);
+    ext_grs_edge_t *e_pos1_26 = ext_grs_act_add_edge(pattern, "pos1_26", 0, n_Load575, n_Vector_Result1_Proj577, 16);
+    ext_grs_edge_t *e_pos1_27 = ext_grs_act_add_edge(pattern, "pos1_27", 0, n_Load590, n_Proj591, 17);
+    ext_grs_edge_t *e_pos1_29 = ext_grs_act_add_edge(pattern, "pos1_29", 0, n_Load605, n_Proj606, 18);
+    ext_grs_edge_t *e_pos2_28 = ext_grs_act_add_edge(pattern, "pos2_28", 1, n_MultipleAdd5683, n_Load575, 19);
+    ext_grs_edge_t *e_pos2_42 = ext_grs_act_add_edge(pattern, "pos2_42", 1, n_MultipleAdd5679, n_Load605, 20);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const603};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31130, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const588};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31133, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5687};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31136, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj561};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31139, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj576};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31142, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result1_Proj577};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31145, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj591};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31148, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj606};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31151, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const556};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31154, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5679};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31157, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_Proj562};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31160, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5681};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31163, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result2_Proj592};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31166, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result3_Proj607};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31169, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5683};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31172, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const552};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31175, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Proj606_1747 = ext_grs_act_add_node_to_keep(pattern, "Proj606_1747", grs_op_Proj, mode_M, 0, n_Proj606);
+       ext_grs_node_t *n_Proj561_1748 = ext_grs_act_add_node_to_keep(pattern, "Proj561_1748", grs_op_Proj, mode_M, 1, n_Proj561);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 22);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 23);
+       ext_grs_node_t *n_Const588_1749 = ext_grs_act_add_node_to_keep(pattern, "Const588_1749", grs_op_Const, mode_Is, 2, n_Const588);
+       ext_grs_node_t *n_Load560_1750 = ext_grs_act_add_node_to_keep(pattern, "Load560_1750", grs_op_Load, mode_T, 3, n_Load560);
+       ext_grs_node_t *n_VProj24_1751 = ext_grs_act_add_node_to_keep(pattern, "VProj24_1751", grs_op_VProj, mode_F, 24, n_Vector_Result0_Proj562);
+       ext_grs_node_t *n_MultipleAdd5687_1752 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5687_1752", grs_op_MultipleAdd, mode_P, 5, n_MultipleAdd5687);
+       ext_grs_node_t *n_Const603_1753 = ext_grs_act_add_node_to_keep(pattern, "Const603_1753", grs_op_Const, mode_Is, 6, n_Const603);
+       ext_grs_node_t *n_MultipleAdd5683_1754 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5683_1754", grs_op_MultipleAdd, mode_P, 7, n_MultipleAdd5683);
+       ext_grs_node_t *n_MultipleAdd5681_1755 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5681_1755", grs_op_MultipleAdd, mode_P, 8, n_MultipleAdd5681);
+       ext_grs_node_t *n_Arg_0_1756 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1756", grs_op_VectorBase, mode_ANY, 9, n_Arg_0);
+       ext_grs_node_t *n_Proj591_1757 = ext_grs_act_add_node_to_keep(pattern, "Proj591_1757", grs_op_Proj, mode_M, 10, n_Proj591);
+       ext_grs_node_t *n_Bad22 = ext_grs_act_add_node(pattern, "Bad22", grs_op_Bad, mode_ANY, 25);
+       ext_grs_node_t *n_Vector_op_Block_1758 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1758", grs_op_Block, mode_BB, 11, n_Vector_op_Block);
+       ext_grs_node_t *n_Proj576_1759 = ext_grs_act_add_node_to_keep(pattern, "Proj576_1759", grs_op_Proj, mode_M, 12, n_Proj576);
+       ext_grs_node_t *n_VProj28_1760 = ext_grs_act_add_node_to_keep(pattern, "VProj28_1760", grs_op_VProj, mode_F, 26, n_Vector_Result3_Proj607);
+       ext_grs_node_t *n_Const552_1761 = ext_grs_act_add_node_to_keep(pattern, "Const552_1761", grs_op_Const, mode_Is, 14, n_Const552);
+       ext_grs_node_t *n_VProj22_1762 = ext_grs_act_add_node_to_keep(pattern, "VProj22_1762", grs_op_VProj, mode_F, 27, n_Vector_Result1_Proj577);
+       ext_grs_node_t *n_Load575_1763 = ext_grs_act_add_node_to_keep(pattern, "Load575_1763", grs_op_Load, mode_T, 16, n_Load575);
+       ext_grs_node_t *n_Const556_1764 = ext_grs_act_add_node_to_keep(pattern, "Const556_1764", grs_op_Const, mode_Is, 17, n_Const556);
+       ext_grs_node_t *n_VProj26_1765 = ext_grs_act_add_node_to_keep(pattern, "VProj26_1765", grs_op_VProj, mode_F, 28, n_Vector_Result2_Proj592);
+       ext_grs_node_t *n_Load605_1766 = ext_grs_act_add_node_to_keep(pattern, "Load605_1766", grs_op_Load, mode_T, 19, n_Load605);
+       ext_grs_node_t *n_MultipleAdd5679_1767 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5679_1767", grs_op_MultipleAdd, mode_P, 20, n_MultipleAdd5679);
+       ext_grs_node_t *n_Load590_1768 = ext_grs_act_add_node_to_keep(pattern, "Load590_1768", grs_op_Load, mode_T, 21, n_Load590);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 29);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_e34_1769 = ext_grs_act_add_edge_to_keep(pattern, "e34_1769", ext_grs_NO_EDGE_POS, n_Const588_1749, n_MultipleAdd5681_1755, 0, e_e34);
+       ext_grs_edge_t *e_e35_1770 = ext_grs_act_add_edge_to_keep(pattern, "e35_1770", ext_grs_NO_EDGE_POS, n_Arg_0_1756, n_MultipleAdd5681_1755, 1, e_e35);
+       ext_grs_edge_t *e_e30_1771 = ext_grs_act_add_edge_to_keep(pattern, "e30_1771", ext_grs_NO_EDGE_POS, n_Const603_1753, n_MultipleAdd5679_1767, 2, e_e30);
+       ext_grs_edge_t *e_e31_1772 = ext_grs_act_add_edge_to_keep(pattern, "e31_1772", ext_grs_NO_EDGE_POS, n_Arg_0_1756, n_MultipleAdd5679_1767, 3, e_e31);
+       ext_grs_edge_t *e_pos2_33_1773 = ext_grs_act_add_edge_to_keep(pattern, "pos2_33_1773", 1, n_MultipleAdd5687_1752, n_Load560_1750, 7, e_pos2_33);
+       ext_grs_edge_t *e_pos2_38_1774 = ext_grs_act_add_edge_to_keep(pattern, "pos2_38_1774", 1, n_MultipleAdd5681_1755, n_Load590_1768, 8, e_pos2_38);
+       ext_grs_edge_t *e_e39_1775 = ext_grs_act_add_edge_to_keep(pattern, "e39_1775", ext_grs_NO_EDGE_POS, n_Const556_1764, n_MultipleAdd5683_1754, 9, e_e39);
+       ext_grs_edge_t *e_e40_1776 = ext_grs_act_add_edge_to_keep(pattern, "e40_1776", ext_grs_NO_EDGE_POS, n_Arg_0_1756, n_MultipleAdd5683_1754, 12, e_e40);
+       ext_grs_edge_t *e_pos1_48_1777 = ext_grs_act_add_edge(pattern, "pos1_48_1777", 0, n_Vector_op, n_Vector_op_ProjM, 21);
+       ext_grs_edge_t *e_pos1_45_1778 = ext_grs_act_add_edge(pattern, "pos1_45_1778", 0, n_Vector_op, n_Vector_op_ProjData, 22);
+       ext_grs_edge_t *e_pos1_46_1779 = ext_grs_act_add_edge(pattern, "pos1_46_1779", 0, n_MultipleAdd5687_1752, n_Vector_op, 23);
+       ext_grs_edge_t *e_pos2_28_1780 = ext_grs_act_add_edge_to_keep(pattern, "pos2_28_1780", 1, n_MultipleAdd5683_1754, n_Load575_1763, 19, e_pos2_28);
+       ext_grs_edge_t *e_pos1_51_1781 = ext_grs_act_add_edge(pattern, "pos1_51_1781", 0, n_Vector_op_ProjData, n_VProj24_1751, 24);
+       ext_grs_edge_t *e_pos1_50_1782 = ext_grs_act_add_edge(pattern, "pos1_50_1782", 0, n_Vector_op_ProjData, n_VProj22_1762, 25);
+       ext_grs_edge_t *e_pos1_53_1783 = ext_grs_act_add_edge(pattern, "pos1_53_1783", 0, n_Vector_op_ProjData, n_VProj28_1760, 26);
+       ext_grs_edge_t *e_pos1_52_1784 = ext_grs_act_add_edge(pattern, "pos1_52_1784", 0, n_Vector_op_ProjData, n_VProj26_1765, 27);
+       ext_grs_edge_t *e_pos0_41_1785 = ext_grs_act_add_edge_to_keep(pattern, "pos0_41_1785", -1, n_Vector_op_Block_1758, n_Load605_1766, 10, e_pos0_41);
+       ext_grs_edge_t *e_e24_1786 = ext_grs_act_add_edge_to_keep(pattern, "e24_1786", ext_grs_NO_EDGE_POS, n_Arg_0_1756, n_MultipleAdd5687_1752, 11, e_e24);
+       ext_grs_edge_t *e_e23_1787 = ext_grs_act_add_edge_to_keep(pattern, "e23_1787", ext_grs_NO_EDGE_POS, n_Const552_1761, n_MultipleAdd5687_1752, 13, e_e23);
+       ext_grs_edge_t *e_pos1_22_1788 = ext_grs_act_add_edge_to_keep(pattern, "pos1_22_1788", 0, n_Load560_1750, n_Proj561_1748, 14, e_pos1_22);
+       ext_grs_edge_t *e_pos0_49_1789 = ext_grs_act_add_edge(pattern, "pos0_49_1789", -1, n_Vector_op_Block_1758, n_Vector_op_ProjM, 28);
+       ext_grs_edge_t *e_pos1_25_1790 = ext_grs_act_add_edge_to_keep(pattern, "pos1_25_1790", 0, n_Load575_1763, n_Proj576_1759, 15, e_pos1_25);
+       ext_grs_edge_t *e_pos0_43_1791 = ext_grs_act_add_edge(pattern, "pos0_43_1791", -1, n_Vector_op_Block_1758, n_Vector_op, 29);
+       ext_grs_edge_t *e_pos0_44_1792 = ext_grs_act_add_edge(pattern, "pos0_44_1792", -1, n_Vector_op_Block_1758, n_Vector_op_ProjData, 30);
+       ext_grs_edge_t *e_pos1_27_1793 = ext_grs_act_add_edge_to_keep(pattern, "pos1_27_1793", 0, n_Load590_1768, n_Proj591_1757, 17, e_pos1_27);
+       ext_grs_edge_t *e_pos1_29_1794 = ext_grs_act_add_edge_to_keep(pattern, "pos1_29_1794", 0, n_Load605_1766, n_Proj606_1747, 18, e_pos1_29);
+       ext_grs_edge_t *e_pos2_47_1795 = ext_grs_act_add_edge(pattern, "pos2_47_1795", 1, n_Bad22, n_Vector_op, 31);
+       ext_grs_edge_t *e_pos2_42_1796 = ext_grs_act_add_edge_to_keep(pattern, "pos2_42_1796", 1, n_MultipleAdd5679_1767, n_Load605_1766, 20, e_pos2_42);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31316);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31319);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31322);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31325);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31328);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31331);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vload_4f_32_variant0 */
+
+
+/* functions for evaluation of conditions of action vload_4f_32_variant1 */
+static int grs_cond_func_31567(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[6/* Const603 */])) == 12;
+}
+static int grs_cond_func_31570(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[2/* Const588 */])) == 8;
+}
+static int grs_cond_func_31573(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[5/* MultipleAdd5687 */]) == 3;
+}
+static int grs_cond_func_31576(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[1/* Proj561 */]) == 0;
+}
+static int grs_cond_func_31579(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[12/* Proj576 */]) == 0;
+}
+static int grs_cond_func_31582(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Vector_Result1_Proj577 */]) == 3;
+}
+static int grs_cond_func_31585(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[10/* Proj591 */]) == 0;
+}
+static int grs_cond_func_31588(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[0/* Proj606 */]) == 0;
+}
+static int grs_cond_func_31591(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[17/* Const556 */])) == 4;
+}
+static int grs_cond_func_31594(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[21/* MultipleAdd5679 */]) == 3;
+}
+static int grs_cond_func_31597(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[4/* Vector_Result0_Proj562 */]) == 3;
+}
+static int grs_cond_func_31600(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[8/* MultipleAdd5681 */]) == 3;
+}
+static int grs_cond_func_31603(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[18/* Vector_Result2_Proj592 */]) == 3;
+}
+static int grs_cond_func_31606(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[13/* Vector_Result3_Proj607 */]) == 3;
+}
+static int grs_cond_func_31609(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[7/* MultipleAdd5683 */]) == 3;
+}
+static int grs_cond_func_31612(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[14/* Const552 */])) == 0;
+}
+
+static void *grs_eval_out_func_31759(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[24/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_31762(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[23/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_31765(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[28/* VProj23 */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_31768(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[25/* VProj25 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_31771(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[29/* VProj27 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_31774(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[27/* VProj29 */], 3);
+  return(NULL);
+}
+/* functions for building the pattern of action vload_4f_32_variant1 */
+static _inline ext_grs_action_t *grs_action_vload_4f_32_variant1_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vload_4f_32_variant1");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Proj606 = ext_grs_act_add_node(pattern, "Proj606", grs_op_Proj, mode_M, 0);
+    ext_grs_node_t *n_Proj561 = ext_grs_act_add_node(pattern, "Proj561", grs_op_Proj, mode_M, 1);
+    ext_grs_node_t *n_Const588 = ext_grs_act_add_node(pattern, "Const588", grs_op_Const, mode_Is, 2);
+    ext_grs_node_t *n_Load560 = ext_grs_act_add_node(pattern, "Load560", grs_op_Load, mode_T, 3);
+    ext_grs_node_t *n_Vector_Result0_Proj562 = ext_grs_act_add_node(pattern, "Vector_Result0_Proj562", grs_op_Proj, mode_F, 4);
+    ext_grs_node_t *n_MultipleAdd5687 = ext_grs_act_add_node(pattern, "MultipleAdd5687", grs_op_MultipleAdd, mode_P, 5);
+    ext_grs_node_t *n_Const603 = ext_grs_act_add_node(pattern, "Const603", grs_op_Const, mode_Is, 6);
+    ext_grs_node_t *n_MultipleAdd5683 = ext_grs_act_add_node(pattern, "MultipleAdd5683", grs_op_MultipleAdd, mode_P, 7);
+    ext_grs_node_t *n_MultipleAdd5681 = ext_grs_act_add_node(pattern, "MultipleAdd5681", grs_op_MultipleAdd, mode_P, 8);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 9);
+    ext_grs_node_t *n_Proj591 = ext_grs_act_add_node(pattern, "Proj591", grs_op_Proj, mode_M, 10);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 11);
+    ext_grs_node_t *n_Proj576 = ext_grs_act_add_node(pattern, "Proj576", grs_op_Proj, mode_M, 12);
+    ext_grs_node_t *n_Vector_Result3_Proj607 = ext_grs_act_add_node(pattern, "Vector_Result3_Proj607", grs_op_Proj, mode_F, 13);
+    ext_grs_node_t *n_Const552 = ext_grs_act_add_node(pattern, "Const552", grs_op_Const, mode_Is, 14);
+    ext_grs_node_t *n_Vector_Result1_Proj577 = ext_grs_act_add_node(pattern, "Vector_Result1_Proj577", grs_op_Proj, mode_F, 15);
+    ext_grs_node_t *n_Load575 = ext_grs_act_add_node(pattern, "Load575", grs_op_Load, mode_T, 16);
+    ext_grs_node_t *n_Const556 = ext_grs_act_add_node(pattern, "Const556", grs_op_Const, mode_Is, 17);
+    ext_grs_node_t *n_Vector_Result2_Proj592 = ext_grs_act_add_node(pattern, "Vector_Result2_Proj592", grs_op_Proj, mode_F, 18);
+    ext_grs_node_t *n_Load605 = ext_grs_act_add_node(pattern, "Load605", grs_op_Load, mode_T, 19);
+    ext_grs_node_t *n_IR_node5688 = ext_grs_act_add_node(pattern, "IR_node5688", grs_op_IR_node, mode_ANY, 20);
+    ext_grs_node_t *n_MultipleAdd5679 = ext_grs_act_add_node(pattern, "MultipleAdd5679", grs_op_MultipleAdd, mode_P, 21);
+    ext_grs_node_t *n_Load590 = ext_grs_act_add_node(pattern, "Load590", grs_op_Load, mode_T, 22);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_e33 = ext_grs_act_add_edge(pattern, "e33", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5679, 0);
+    ext_grs_edge_t *e_e34 = ext_grs_act_add_edge(pattern, "e34", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5679, 1);
+    ext_grs_edge_t *e_pos1_31 = ext_grs_act_add_edge(pattern, "pos1_31", 0, n_Load605, n_Proj606, 2);
+    ext_grs_edge_t *e_e32 = ext_grs_act_add_edge(pattern, "e32", ext_grs_NO_EDGE_POS, n_Const603, n_MultipleAdd5679, 3);
+    ext_grs_edge_t *e_pos1_35 = ext_grs_act_add_edge(pattern, "pos1_35", 0, n_Load560, n_Vector_Result0_Proj562, 4);
+    ext_grs_edge_t *e_pos2_36 = ext_grs_act_add_edge(pattern, "pos2_36", 1, n_MultipleAdd5687, n_Load560, 5);
+    ext_grs_edge_t *e_e38 = ext_grs_act_add_edge(pattern, "e38", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5681, 6);
+    ext_grs_edge_t *e_e37 = ext_grs_act_add_edge(pattern, "e37", ext_grs_NO_EDGE_POS, n_Const588, n_MultipleAdd5681, 7);
+    ext_grs_edge_t *e_e39 = ext_grs_act_add_edge(pattern, "e39", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5681, 8);
+    ext_grs_edge_t *e_pos2_30 = ext_grs_act_add_edge(pattern, "pos2_30", 1, n_MultipleAdd5683, n_Load575, 9);
+    ext_grs_edge_t *e_pos1_40 = ext_grs_act_add_edge(pattern, "pos1_40", 0, n_Load590, n_Vector_Result2_Proj592, 10);
+    ext_grs_edge_t *e_e44 = ext_grs_act_add_edge(pattern, "e44", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5683, 11);
+    ext_grs_edge_t *e_pos1_41 = ext_grs_act_add_edge(pattern, "pos1_41", 0, n_Load605, n_Vector_Result3_Proj607, 12);
+    ext_grs_edge_t *e_e45 = ext_grs_act_add_edge(pattern, "e45", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5683, 13);
+    ext_grs_edge_t *e_e24 = ext_grs_act_add_edge(pattern, "e24", ext_grs_NO_EDGE_POS, n_Const552, n_MultipleAdd5687, 14);
+    ext_grs_edge_t *e_e43 = ext_grs_act_add_edge(pattern, "e43", ext_grs_NO_EDGE_POS, n_Const556, n_MultipleAdd5683, 15);
+    ext_grs_edge_t *e_e25 = ext_grs_act_add_edge(pattern, "e25", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5687, 16);
+    ext_grs_edge_t *e_pos0_46 = ext_grs_act_add_edge(pattern, "pos0_46", -1, n_Vector_op_Block, n_Load605, 17);
+    ext_grs_edge_t *e_pos1_23 = ext_grs_act_add_edge(pattern, "pos1_23", 0, n_Load560, n_Proj561, 18);
+    ext_grs_edge_t *e_pos1_27 = ext_grs_act_add_edge(pattern, "pos1_27", 0, n_Load575, n_Proj576, 19);
+    ext_grs_edge_t *e_pos1_28 = ext_grs_act_add_edge(pattern, "pos1_28", 0, n_Load575, n_Vector_Result1_Proj577, 20);
+    ext_grs_edge_t *e_pos1_29 = ext_grs_act_add_edge(pattern, "pos1_29", 0, n_Load590, n_Proj591, 21);
+    ext_grs_edge_t *e_pos2_47 = ext_grs_act_add_edge(pattern, "pos2_47", 1, n_MultipleAdd5679, n_Load605, 22);
+    ext_grs_edge_t *e_pos2_42 = ext_grs_act_add_edge(pattern, "pos2_42", 1, n_MultipleAdd5681, n_Load590, 23);
+    ext_grs_edge_t *e_e26 = ext_grs_act_add_edge(pattern, "e26", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5687, 24);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const603};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31567, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const588};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31570, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5687};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31573, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj561};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31576, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj576};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31579, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result1_Proj577};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31582, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj591};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31585, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj606};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31588, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const556};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31591, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5679};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31594, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_Proj562};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31597, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5681};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31600, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result2_Proj592};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31603, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result3_Proj607};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31606, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5683};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31609, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const552};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_31612, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Proj606_1797 = ext_grs_act_add_node_to_keep(pattern, "Proj606_1797", grs_op_Proj, mode_M, 0, n_Proj606);
+       ext_grs_node_t *n_Proj561_1798 = ext_grs_act_add_node_to_keep(pattern, "Proj561_1798", grs_op_Proj, mode_M, 1, n_Proj561);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 23);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 24);
+       ext_grs_node_t *n_Const588_1799 = ext_grs_act_add_node_to_keep(pattern, "Const588_1799", grs_op_Const, mode_Is, 2, n_Const588);
+       ext_grs_node_t *n_Load560_1800 = ext_grs_act_add_node_to_keep(pattern, "Load560_1800", grs_op_Load, mode_T, 3, n_Load560);
+       ext_grs_node_t *n_VProj25_1801 = ext_grs_act_add_node_to_keep(pattern, "VProj25_1801", grs_op_VProj, mode_F, 25, n_Vector_Result0_Proj562);
+       ext_grs_node_t *n_MultipleAdd5687_1802 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5687_1802", grs_op_MultipleAdd, mode_P, 5, n_MultipleAdd5687);
+       ext_grs_node_t *n_Const603_1803 = ext_grs_act_add_node_to_keep(pattern, "Const603_1803", grs_op_Const, mode_Is, 6, n_Const603);
+       ext_grs_node_t *n_MultipleAdd5683_1804 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5683_1804", grs_op_MultipleAdd, mode_P, 7, n_MultipleAdd5683);
+       ext_grs_node_t *n_MultipleAdd5681_1805 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5681_1805", grs_op_MultipleAdd, mode_P, 8, n_MultipleAdd5681);
+       ext_grs_node_t *n_Arg_0_1806 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1806", grs_op_VectorBase, mode_ANY, 9, n_Arg_0);
+       ext_grs_node_t *n_Proj591_1807 = ext_grs_act_add_node_to_keep(pattern, "Proj591_1807", grs_op_Proj, mode_M, 10, n_Proj591);
+       ext_grs_node_t *n_Bad23 = ext_grs_act_add_node(pattern, "Bad23", grs_op_Bad, mode_ANY, 26);
+       ext_grs_node_t *n_Vector_op_Block_1808 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1808", grs_op_Block, mode_BB, 11, n_Vector_op_Block);
+       ext_grs_node_t *n_Proj576_1809 = ext_grs_act_add_node_to_keep(pattern, "Proj576_1809", grs_op_Proj, mode_M, 12, n_Proj576);
+       ext_grs_node_t *n_VProj29_1810 = ext_grs_act_add_node_to_keep(pattern, "VProj29_1810", grs_op_VProj, mode_F, 27, n_Vector_Result3_Proj607);
+       ext_grs_node_t *n_Const552_1811 = ext_grs_act_add_node_to_keep(pattern, "Const552_1811", grs_op_Const, mode_Is, 14, n_Const552);
+       ext_grs_node_t *n_VProj23_1812 = ext_grs_act_add_node_to_keep(pattern, "VProj23_1812", grs_op_VProj, mode_F, 28, n_Vector_Result1_Proj577);
+       ext_grs_node_t *n_Load575_1813 = ext_grs_act_add_node_to_keep(pattern, "Load575_1813", grs_op_Load, mode_T, 16, n_Load575);
+       ext_grs_node_t *n_Const556_1814 = ext_grs_act_add_node_to_keep(pattern, "Const556_1814", grs_op_Const, mode_Is, 17, n_Const556);
+       ext_grs_node_t *n_VProj27_1815 = ext_grs_act_add_node_to_keep(pattern, "VProj27_1815", grs_op_VProj, mode_F, 29, n_Vector_Result2_Proj592);
+       ext_grs_node_t *n_Load605_1816 = ext_grs_act_add_node_to_keep(pattern, "Load605_1816", grs_op_Load, mode_T, 19, n_Load605);
+       ext_grs_node_t *n_MultipleAdd5679_1817 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5679_1817", grs_op_MultipleAdd, mode_P, 21, n_MultipleAdd5679);
+       ext_grs_node_t *n_IR_node5688_1818 = ext_grs_act_add_node_to_keep(pattern, "IR_node5688_1818", grs_op_IR_node, mode_ANY, 20, n_IR_node5688);
+       ext_grs_node_t *n_Load590_1819 = ext_grs_act_add_node_to_keep(pattern, "Load590_1819", grs_op_Load, mode_T, 22, n_Load590);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 30);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_e33_1820 = ext_grs_act_add_edge_to_keep(pattern, "e33_1820", ext_grs_NO_EDGE_POS, n_Arg_0_1806, n_MultipleAdd5679_1817, 0, e_e33);
+       ext_grs_edge_t *e_pos1_31_1821 = ext_grs_act_add_edge_to_keep(pattern, "pos1_31_1821", 0, n_Load605_1816, n_Proj606_1797, 2, e_pos1_31);
+       ext_grs_edge_t *e_e34_1822 = ext_grs_act_add_edge_to_keep(pattern, "e34_1822", ext_grs_NO_EDGE_POS, n_IR_node5688_1818, n_MultipleAdd5679_1817, 1, e_e34);
+       ext_grs_edge_t *e_e32_1823 = ext_grs_act_add_edge_to_keep(pattern, "e32_1823", ext_grs_NO_EDGE_POS, n_Const603_1803, n_MultipleAdd5679_1817, 3, e_e32);
+       ext_grs_edge_t *e_pos2_36_1824 = ext_grs_act_add_edge_to_keep(pattern, "pos2_36_1824", 1, n_MultipleAdd5687_1802, n_Load560_1800, 5, e_pos2_36);
+       ext_grs_edge_t *e_e38_1825 = ext_grs_act_add_edge_to_keep(pattern, "e38_1825", ext_grs_NO_EDGE_POS, n_Arg_0_1806, n_MultipleAdd5681_1805, 6, e_e38);
+       ext_grs_edge_t *e_e37_1826 = ext_grs_act_add_edge_to_keep(pattern, "e37_1826", ext_grs_NO_EDGE_POS, n_Const588_1799, n_MultipleAdd5681_1805, 7, e_e37);
+       ext_grs_edge_t *e_e39_1827 = ext_grs_act_add_edge_to_keep(pattern, "e39_1827", ext_grs_NO_EDGE_POS, n_IR_node5688_1818, n_MultipleAdd5681_1805, 8, e_e39);
+       ext_grs_edge_t *e_pos2_30_1828 = ext_grs_act_add_edge_to_keep(pattern, "pos2_30_1828", 1, n_MultipleAdd5683_1804, n_Load575_1813, 9, e_pos2_30);
+       ext_grs_edge_t *e_e44_1829 = ext_grs_act_add_edge_to_keep(pattern, "e44_1829", ext_grs_NO_EDGE_POS, n_Arg_0_1806, n_MultipleAdd5683_1804, 11, e_e44);
+       ext_grs_edge_t *e_e45_1830 = ext_grs_act_add_edge_to_keep(pattern, "e45_1830", ext_grs_NO_EDGE_POS, n_IR_node5688_1818, n_MultipleAdd5683_1804, 13, e_e45);
+       ext_grs_edge_t *e_e43_1831 = ext_grs_act_add_edge_to_keep(pattern, "e43_1831", ext_grs_NO_EDGE_POS, n_Const556_1814, n_MultipleAdd5683_1804, 15, e_e43);
+       ext_grs_edge_t *e_pos0_54_1832 = ext_grs_act_add_edge(pattern, "pos0_54_1832", -1, n_Vector_op_Block_1808, n_Vector_op_ProjM, 25);
+       ext_grs_edge_t *e_pos1_55_1833 = ext_grs_act_add_edge(pattern, "pos1_55_1833", 0, n_Vector_op_ProjData, n_VProj23_1812, 26);
+       ext_grs_edge_t *e_pos1_57_1834 = ext_grs_act_add_edge(pattern, "pos1_57_1834", 0, n_Vector_op_ProjData, n_VProj27_1815, 27);
+       ext_grs_edge_t *e_pos1_56_1835 = ext_grs_act_add_edge(pattern, "pos1_56_1835", 0, n_Vector_op_ProjData, n_VProj25_1801, 28);
+       ext_grs_edge_t *e_pos1_58_1836 = ext_grs_act_add_edge(pattern, "pos1_58_1836", 0, n_Vector_op_ProjData, n_VProj29_1810, 29);
+       ext_grs_edge_t *e_pos2_52_1837 = ext_grs_act_add_edge(pattern, "pos2_52_1837", 1, n_Bad23, n_Vector_op, 30);
+       ext_grs_edge_t *e_pos1_51_1838 = ext_grs_act_add_edge(pattern, "pos1_51_1838", 0, n_MultipleAdd5687_1802, n_Vector_op, 31);
+       ext_grs_edge_t *e_pos1_50_1839 = ext_grs_act_add_edge(pattern, "pos1_50_1839", 0, n_Vector_op, n_Vector_op_ProjData, 32);
+       ext_grs_edge_t *e_pos1_53_1840 = ext_grs_act_add_edge(pattern, "pos1_53_1840", 0, n_Vector_op, n_Vector_op_ProjM, 33);
+       ext_grs_edge_t *e_e24_1841 = ext_grs_act_add_edge_to_keep(pattern, "e24_1841", ext_grs_NO_EDGE_POS, n_Const552_1811, n_MultipleAdd5687_1802, 14, e_e24);
+       ext_grs_edge_t *e_e25_1842 = ext_grs_act_add_edge_to_keep(pattern, "e25_1842", ext_grs_NO_EDGE_POS, n_Arg_0_1806, n_MultipleAdd5687_1802, 16, e_e25);
+       ext_grs_edge_t *e_pos0_46_1843 = ext_grs_act_add_edge_to_keep(pattern, "pos0_46_1843", -1, n_Vector_op_Block_1808, n_Load605_1816, 17, e_pos0_46);
+       ext_grs_edge_t *e_pos0_48_1844 = ext_grs_act_add_edge(pattern, "pos0_48_1844", -1, n_Vector_op_Block_1808, n_Vector_op, 34);
+       ext_grs_edge_t *e_pos1_23_1845 = ext_grs_act_add_edge_to_keep(pattern, "pos1_23_1845", 0, n_Load560_1800, n_Proj561_1798, 18, e_pos1_23);
+       ext_grs_edge_t *e_pos0_49_1846 = ext_grs_act_add_edge(pattern, "pos0_49_1846", -1, n_Vector_op_Block_1808, n_Vector_op_ProjData, 35);
+       ext_grs_edge_t *e_pos1_27_1847 = ext_grs_act_add_edge_to_keep(pattern, "pos1_27_1847", 0, n_Load575_1813, n_Proj576_1809, 19, e_pos1_27);
+       ext_grs_edge_t *e_pos1_29_1848 = ext_grs_act_add_edge_to_keep(pattern, "pos1_29_1848", 0, n_Load590_1819, n_Proj591_1807, 21, e_pos1_29);
+       ext_grs_edge_t *e_pos2_47_1849 = ext_grs_act_add_edge_to_keep(pattern, "pos2_47_1849", 1, n_MultipleAdd5679_1817, n_Load605_1816, 22, e_pos2_47);
+       ext_grs_edge_t *e_pos2_42_1850 = ext_grs_act_add_edge_to_keep(pattern, "pos2_42_1850", 1, n_MultipleAdd5681_1805, n_Load590_1819, 23, e_pos2_42);
+       ext_grs_edge_t *e_e26_1851 = ext_grs_act_add_edge_to_keep(pattern, "e26_1851", ext_grs_NO_EDGE_POS, n_IR_node5688_1818, n_MultipleAdd5687_1802, 24, e_e26);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31759);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31762);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31765);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31768);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31771);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_31774);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vload_4f_32_variant1 */
+
+
+/* functions for evaluation of conditions of action vload_4f_32_variant2 */
+static int grs_cond_func_32028(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[6/* Const603 */])) == 12;
+}
+static int grs_cond_func_32031(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[2/* Const588 */])) == 8;
+}
+static int grs_cond_func_32034(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[5/* MultipleAdd5687 */]) == 4;
+}
+static int grs_cond_func_32037(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[1/* Proj561 */]) == 0;
+}
+static int grs_cond_func_32040(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[12/* Proj576 */]) == 0;
+}
+static int grs_cond_func_32043(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Vector_Result1_Proj577 */]) == 3;
+}
+static int grs_cond_func_32046(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[10/* Proj591 */]) == 0;
+}
+static int grs_cond_func_32049(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[0/* Proj606 */]) == 0;
+}
+static int grs_cond_func_32052(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[17/* Const556 */])) == 4;
+}
+static int grs_cond_func_32055(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[22/* MultipleAdd5679 */]) == 4;
+}
+static int grs_cond_func_32058(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[4/* Vector_Result0_Proj562 */]) == 3;
+}
+static int grs_cond_func_32061(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[8/* MultipleAdd5681 */]) == 4;
+}
+static int grs_cond_func_32064(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[18/* Vector_Result2_Proj592 */]) == 3;
+}
+static int grs_cond_func_32067(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[13/* Vector_Result3_Proj607 */]) == 3;
+}
+static int grs_cond_func_32070(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[7/* MultipleAdd5683 */]) == 4;
+}
+static int grs_cond_func_32073(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[14/* Const552 */])) == 0;
+}
+
+static void *grs_eval_out_func_32226(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[25/* Vector_op_ProjData */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_32229(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[24/* Vector_op_ProjM */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_32232(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[29/* VProj24 */], 1);
+  return(NULL);
+}
+static void *grs_eval_out_func_32235(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[26/* VProj26 */], 0);
+  return(NULL);
+}
+static void *grs_eval_out_func_32238(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[30/* VProj28 */], 2);
+  return(NULL);
+}
+static void *grs_eval_out_func_32241(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+set_VProj_proj(rpl_node_map[28/* VProj30 */], 3);
+  return(NULL);
+}
+/* functions for building the pattern of action vload_4f_32_variant2 */
+static _inline ext_grs_action_t *grs_action_vload_4f_32_variant2_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vload_4f_32_variant2");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_Proj606 = ext_grs_act_add_node(pattern, "Proj606", grs_op_Proj, mode_M, 0);
+    ext_grs_node_t *n_Proj561 = ext_grs_act_add_node(pattern, "Proj561", grs_op_Proj, mode_M, 1);
+    ext_grs_node_t *n_Const588 = ext_grs_act_add_node(pattern, "Const588", grs_op_Const, mode_Is, 2);
+    ext_grs_node_t *n_Load560 = ext_grs_act_add_node(pattern, "Load560", grs_op_Load, mode_T, 3);
+    ext_grs_node_t *n_Vector_Result0_Proj562 = ext_grs_act_add_node(pattern, "Vector_Result0_Proj562", grs_op_Proj, mode_F, 4);
+    ext_grs_node_t *n_MultipleAdd5687 = ext_grs_act_add_node(pattern, "MultipleAdd5687", grs_op_MultipleAdd, mode_P, 5);
+    ext_grs_node_t *n_Const603 = ext_grs_act_add_node(pattern, "Const603", grs_op_Const, mode_Is, 6);
+    ext_grs_node_t *n_MultipleAdd5683 = ext_grs_act_add_node(pattern, "MultipleAdd5683", grs_op_MultipleAdd, mode_P, 7);
+    ext_grs_node_t *n_MultipleAdd5681 = ext_grs_act_add_node(pattern, "MultipleAdd5681", grs_op_MultipleAdd, mode_P, 8);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 9);
+    ext_grs_node_t *n_Proj591 = ext_grs_act_add_node(pattern, "Proj591", grs_op_Proj, mode_M, 10);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 11);
+    ext_grs_node_t *n_Proj576 = ext_grs_act_add_node(pattern, "Proj576", grs_op_Proj, mode_M, 12);
+    ext_grs_node_t *n_Vector_Result3_Proj607 = ext_grs_act_add_node(pattern, "Vector_Result3_Proj607", grs_op_Proj, mode_F, 13);
+    ext_grs_node_t *n_Const552 = ext_grs_act_add_node(pattern, "Const552", grs_op_Const, mode_Is, 14);
+    ext_grs_node_t *n_Vector_Result1_Proj577 = ext_grs_act_add_node(pattern, "Vector_Result1_Proj577", grs_op_Proj, mode_F, 15);
+    ext_grs_node_t *n_Load575 = ext_grs_act_add_node(pattern, "Load575", grs_op_Load, mode_T, 16);
+    ext_grs_node_t *n_Const556 = ext_grs_act_add_node(pattern, "Const556", grs_op_Const, mode_Is, 17);
+    ext_grs_node_t *n_Vector_Result2_Proj592 = ext_grs_act_add_node(pattern, "Vector_Result2_Proj592", grs_op_Proj, mode_F, 18);
+    ext_grs_node_t *n_Load605 = ext_grs_act_add_node(pattern, "Load605", grs_op_Load, mode_T, 19);
+    ext_grs_node_t *n_IR_node5689 = ext_grs_act_add_node(pattern, "IR_node5689", grs_op_IR_node, mode_ANY, 20);
+    ext_grs_node_t *n_IR_node5688 = ext_grs_act_add_node(pattern, "IR_node5688", grs_op_IR_node, mode_ANY, 21);
+    ext_grs_node_t *n_MultipleAdd5679 = ext_grs_act_add_node(pattern, "MultipleAdd5679", grs_op_MultipleAdd, mode_P, 22);
+    ext_grs_node_t *n_Load590 = ext_grs_act_add_node(pattern, "Load590", grs_op_Load, mode_T, 23);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_30 = ext_grs_act_add_edge(pattern, "pos1_30", 0, n_Load575, n_Vector_Result1_Proj577, 0);
+    ext_grs_edge_t *e_pos1_31 = ext_grs_act_add_edge(pattern, "pos1_31", 0, n_Load590, n_Proj591, 1);
+    ext_grs_edge_t *e_e34 = ext_grs_act_add_edge(pattern, "e34", ext_grs_NO_EDGE_POS, n_Const603, n_MultipleAdd5679, 2);
+    ext_grs_edge_t *e_e35 = ext_grs_act_add_edge(pattern, "e35", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5679, 3);
+    ext_grs_edge_t *e_e36 = ext_grs_act_add_edge(pattern, "e36", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5679, 4);
+    ext_grs_edge_t *e_pos1_38 = ext_grs_act_add_edge(pattern, "pos1_38", 0, n_Load560, n_Vector_Result0_Proj562, 5);
+    ext_grs_edge_t *e_pos1_33 = ext_grs_act_add_edge(pattern, "pos1_33", 0, n_Load605, n_Proj606, 6);
+    ext_grs_edge_t *e_pos2_39 = ext_grs_act_add_edge(pattern, "pos2_39", 1, n_MultipleAdd5687, n_Load560, 7);
+    ext_grs_edge_t *e_pos2_32 = ext_grs_act_add_edge(pattern, "pos2_32", 1, n_MultipleAdd5683, n_Load575, 8);
+    ext_grs_edge_t *e_e37 = ext_grs_act_add_edge(pattern, "e37", ext_grs_NO_EDGE_POS, n_IR_node5689, n_MultipleAdd5679, 9);
+    ext_grs_edge_t *e_e47 = ext_grs_act_add_edge(pattern, "e47", ext_grs_NO_EDGE_POS, n_Const556, n_MultipleAdd5683, 10);
+    ext_grs_edge_t *e_e42 = ext_grs_act_add_edge(pattern, "e42", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5681, 11);
+    ext_grs_edge_t *e_e43 = ext_grs_act_add_edge(pattern, "e43", ext_grs_NO_EDGE_POS, n_IR_node5689, n_MultipleAdd5681, 12);
+    ext_grs_edge_t *e_e40 = ext_grs_act_add_edge(pattern, "e40", ext_grs_NO_EDGE_POS, n_Const588, n_MultipleAdd5681, 13);
+    ext_grs_edge_t *e_e41 = ext_grs_act_add_edge(pattern, "e41", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5681, 14);
+    ext_grs_edge_t *e_pos1_44 = ext_grs_act_add_edge(pattern, "pos1_44", 0, n_Load590, n_Vector_Result2_Proj592, 15);
+    ext_grs_edge_t *e_pos1_45 = ext_grs_act_add_edge(pattern, "pos1_45", 0, n_Load605, n_Vector_Result3_Proj607, 16);
+    ext_grs_edge_t *e_e49 = ext_grs_act_add_edge(pattern, "e49", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5683, 17);
+    ext_grs_edge_t *e_e48 = ext_grs_act_add_edge(pattern, "e48", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5683, 18);
+    ext_grs_edge_t *e_pos0_51 = ext_grs_act_add_edge(pattern, "pos0_51", -1, n_Vector_op_Block, n_Load605, 19);
+    ext_grs_edge_t *e_e50 = ext_grs_act_add_edge(pattern, "e50", ext_grs_NO_EDGE_POS, n_IR_node5689, n_MultipleAdd5683, 20);
+    ext_grs_edge_t *e_pos2_52 = ext_grs_act_add_edge(pattern, "pos2_52", 1, n_MultipleAdd5679, n_Load605, 21);
+    ext_grs_edge_t *e_e25 = ext_grs_act_add_edge(pattern, "e25", ext_grs_NO_EDGE_POS, n_Const552, n_MultipleAdd5687, 22);
+    ext_grs_edge_t *e_pos1_24 = ext_grs_act_add_edge(pattern, "pos1_24", 0, n_Load560, n_Proj561, 23);
+    ext_grs_edge_t *e_pos1_29 = ext_grs_act_add_edge(pattern, "pos1_29", 0, n_Load575, n_Proj576, 24);
+    ext_grs_edge_t *e_pos2_46 = ext_grs_act_add_edge(pattern, "pos2_46", 1, n_MultipleAdd5681, n_Load590, 25);
+    ext_grs_edge_t *e_e28 = ext_grs_act_add_edge(pattern, "e28", ext_grs_NO_EDGE_POS, n_IR_node5689, n_MultipleAdd5687, 26);
+    ext_grs_edge_t *e_e27 = ext_grs_act_add_edge(pattern, "e27", ext_grs_NO_EDGE_POS, n_IR_node5688, n_MultipleAdd5687, 27);
+    ext_grs_edge_t *e_e26 = ext_grs_act_add_edge(pattern, "e26", ext_grs_NO_EDGE_POS, n_Arg_0, n_MultipleAdd5687, 28);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const603};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32028, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const588};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32031, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5687};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32034, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj561};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32037, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj576};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32040, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result1_Proj577};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32043, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj591};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32046, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj606};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32049, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const556};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32052, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5679};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32055, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result0_Proj562};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32058, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5681};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32061, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result2_Proj592};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32064, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Vector_Result3_Proj607};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32067, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5683};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32070, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const552};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_32073, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_Proj606_1852 = ext_grs_act_add_node_to_keep(pattern, "Proj606_1852", grs_op_Proj, mode_M, 0, n_Proj606);
+       ext_grs_node_t *n_Proj561_1853 = ext_grs_act_add_node_to_keep(pattern, "Proj561_1853", grs_op_Proj, mode_M, 1, n_Proj561);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 24);
+       ext_grs_node_t *n_Vector_op_ProjData = ext_grs_act_add_node(pattern, "Vector_op_ProjData", grs_op_Proj, mode_LLu, 25);
+       ext_grs_node_t *n_Const588_1854 = ext_grs_act_add_node_to_keep(pattern, "Const588_1854", grs_op_Const, mode_Is, 2, n_Const588);
+       ext_grs_node_t *n_Load560_1855 = ext_grs_act_add_node_to_keep(pattern, "Load560_1855", grs_op_Load, mode_T, 3, n_Load560);
+       ext_grs_node_t *n_VProj26_1856 = ext_grs_act_add_node_to_keep(pattern, "VProj26_1856", grs_op_VProj, mode_F, 26, n_Vector_Result0_Proj562);
+       ext_grs_node_t *n_MultipleAdd5687_1857 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5687_1857", grs_op_MultipleAdd, mode_P, 5, n_MultipleAdd5687);
+       ext_grs_node_t *n_Const603_1858 = ext_grs_act_add_node_to_keep(pattern, "Const603_1858", grs_op_Const, mode_Is, 6, n_Const603);
+       ext_grs_node_t *n_MultipleAdd5683_1859 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5683_1859", grs_op_MultipleAdd, mode_P, 7, n_MultipleAdd5683);
+       ext_grs_node_t *n_MultipleAdd5681_1860 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5681_1860", grs_op_MultipleAdd, mode_P, 8, n_MultipleAdd5681);
+       ext_grs_node_t *n_Bad24 = ext_grs_act_add_node(pattern, "Bad24", grs_op_Bad, mode_ANY, 27);
+       ext_grs_node_t *n_Arg_0_1861 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1861", grs_op_VectorBase, mode_ANY, 9, n_Arg_0);
+       ext_grs_node_t *n_Proj591_1862 = ext_grs_act_add_node_to_keep(pattern, "Proj591_1862", grs_op_Proj, mode_M, 10, n_Proj591);
+       ext_grs_node_t *n_Vector_op_Block_1863 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1863", grs_op_Block, mode_BB, 11, n_Vector_op_Block);
+       ext_grs_node_t *n_Proj576_1864 = ext_grs_act_add_node_to_keep(pattern, "Proj576_1864", grs_op_Proj, mode_M, 12, n_Proj576);
+       ext_grs_node_t *n_VProj30_1865 = ext_grs_act_add_node_to_keep(pattern, "VProj30_1865", grs_op_VProj, mode_F, 28, n_Vector_Result3_Proj607);
+       ext_grs_node_t *n_Const552_1866 = ext_grs_act_add_node_to_keep(pattern, "Const552_1866", grs_op_Const, mode_Is, 14, n_Const552);
+       ext_grs_node_t *n_VProj24_1867 = ext_grs_act_add_node_to_keep(pattern, "VProj24_1867", grs_op_VProj, mode_F, 29, n_Vector_Result1_Proj577);
+       ext_grs_node_t *n_Load575_1868 = ext_grs_act_add_node_to_keep(pattern, "Load575_1868", grs_op_Load, mode_T, 16, n_Load575);
+       ext_grs_node_t *n_Const556_1869 = ext_grs_act_add_node_to_keep(pattern, "Const556_1869", grs_op_Const, mode_Is, 17, n_Const556);
+       ext_grs_node_t *n_VProj28_1870 = ext_grs_act_add_node_to_keep(pattern, "VProj28_1870", grs_op_VProj, mode_F, 30, n_Vector_Result2_Proj592);
+       ext_grs_node_t *n_IR_node5689_1871 = ext_grs_act_add_node_to_keep(pattern, "IR_node5689_1871", grs_op_IR_node, mode_ANY, 20, n_IR_node5689);
+       ext_grs_node_t *n_Load605_1872 = ext_grs_act_add_node_to_keep(pattern, "Load605_1872", grs_op_Load, mode_T, 19, n_Load605);
+       ext_grs_node_t *n_MultipleAdd5679_1873 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5679_1873", grs_op_MultipleAdd, mode_P, 22, n_MultipleAdd5679);
+       ext_grs_node_t *n_IR_node5688_1874 = ext_grs_act_add_node_to_keep(pattern, "IR_node5688_1874", grs_op_IR_node, mode_ANY, 21, n_IR_node5688);
+       ext_grs_node_t *n_Load590_1875 = ext_grs_act_add_node_to_keep(pattern, "Load590_1875", grs_op_Load, mode_T, 23, n_Load590);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 31);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_e34_1876 = ext_grs_act_add_edge_to_keep(pattern, "e34_1876", ext_grs_NO_EDGE_POS, n_Const603_1858, n_MultipleAdd5679_1873, 2, e_e34);
+       ext_grs_edge_t *e_pos1_31_1877 = ext_grs_act_add_edge_to_keep(pattern, "pos1_31_1877", 0, n_Load590_1875, n_Proj591_1862, 1, e_pos1_31);
+       ext_grs_edge_t *e_e35_1878 = ext_grs_act_add_edge_to_keep(pattern, "e35_1878", ext_grs_NO_EDGE_POS, n_Arg_0_1861, n_MultipleAdd5679_1873, 3, e_e35);
+       ext_grs_edge_t *e_e36_1879 = ext_grs_act_add_edge_to_keep(pattern, "e36_1879", ext_grs_NO_EDGE_POS, n_IR_node5688_1874, n_MultipleAdd5679_1873, 4, e_e36);
+       ext_grs_edge_t *e_pos1_33_1880 = ext_grs_act_add_edge_to_keep(pattern, "pos1_33_1880", 0, n_Load605_1872, n_Proj606_1852, 6, e_pos1_33);
+       ext_grs_edge_t *e_pos2_39_1881 = ext_grs_act_add_edge_to_keep(pattern, "pos2_39_1881", 1, n_MultipleAdd5687_1857, n_Load560_1855, 7, e_pos2_39);
+       ext_grs_edge_t *e_e37_1882 = ext_grs_act_add_edge_to_keep(pattern, "e37_1882", ext_grs_NO_EDGE_POS, n_IR_node5689_1871, n_MultipleAdd5679_1873, 9, e_e37);
+       ext_grs_edge_t *e_pos2_32_1883 = ext_grs_act_add_edge_to_keep(pattern, "pos2_32_1883", 1, n_MultipleAdd5683_1859, n_Load575_1868, 8, e_pos2_32);
+       ext_grs_edge_t *e_e47_1884 = ext_grs_act_add_edge_to_keep(pattern, "e47_1884", ext_grs_NO_EDGE_POS, n_Const556_1869, n_MultipleAdd5683_1859, 10, e_e47);
+       ext_grs_edge_t *e_e42_1885 = ext_grs_act_add_edge_to_keep(pattern, "e42_1885", ext_grs_NO_EDGE_POS, n_IR_node5688_1874, n_MultipleAdd5681_1860, 11, e_e42);
+       ext_grs_edge_t *e_e43_1886 = ext_grs_act_add_edge_to_keep(pattern, "e43_1886", ext_grs_NO_EDGE_POS, n_IR_node5689_1871, n_MultipleAdd5681_1860, 12, e_e43);
+       ext_grs_edge_t *e_e40_1887 = ext_grs_act_add_edge_to_keep(pattern, "e40_1887", ext_grs_NO_EDGE_POS, n_Const588_1854, n_MultipleAdd5681_1860, 13, e_e40);
+       ext_grs_edge_t *e_e41_1888 = ext_grs_act_add_edge_to_keep(pattern, "e41_1888", ext_grs_NO_EDGE_POS, n_Arg_0_1861, n_MultipleAdd5681_1860, 14, e_e41);
+       ext_grs_edge_t *e_e49_1889 = ext_grs_act_add_edge_to_keep(pattern, "e49_1889", ext_grs_NO_EDGE_POS, n_IR_node5688_1874, n_MultipleAdd5683_1859, 17, e_e49);
+       ext_grs_edge_t *e_e48_1890 = ext_grs_act_add_edge_to_keep(pattern, "e48_1890", ext_grs_NO_EDGE_POS, n_Arg_0_1861, n_MultipleAdd5683_1859, 18, e_e48);
+       ext_grs_edge_t *e_pos0_51_1891 = ext_grs_act_add_edge_to_keep(pattern, "pos0_51_1891", -1, n_Vector_op_Block_1863, n_Load605_1872, 19, e_pos0_51);
+       ext_grs_edge_t *e_e50_1892 = ext_grs_act_add_edge_to_keep(pattern, "e50_1892", ext_grs_NO_EDGE_POS, n_IR_node5689_1871, n_MultipleAdd5683_1859, 20, e_e50);
+       ext_grs_edge_t *e_pos0_59_1893 = ext_grs_act_add_edge(pattern, "pos0_59_1893", -1, n_Vector_op_Block_1863, n_Vector_op_ProjM, 29);
+       ext_grs_edge_t *e_pos0_53_1894 = ext_grs_act_add_edge(pattern, "pos0_53_1894", -1, n_Vector_op_Block_1863, n_Vector_op, 30);
+       ext_grs_edge_t *e_pos0_54_1895 = ext_grs_act_add_edge(pattern, "pos0_54_1895", -1, n_Vector_op_Block_1863, n_Vector_op_ProjData, 31);
+       ext_grs_edge_t *e_pos1_55_1896 = ext_grs_act_add_edge(pattern, "pos1_55_1896", 0, n_Vector_op, n_Vector_op_ProjData, 32);
+       ext_grs_edge_t *e_pos1_56_1897 = ext_grs_act_add_edge(pattern, "pos1_56_1897", 0, n_MultipleAdd5687_1857, n_Vector_op, 33);
+       ext_grs_edge_t *e_pos2_57_1898 = ext_grs_act_add_edge(pattern, "pos2_57_1898", 1, n_Bad24, n_Vector_op, 34);
+       ext_grs_edge_t *e_pos1_58_1899 = ext_grs_act_add_edge(pattern, "pos1_58_1899", 0, n_Vector_op, n_Vector_op_ProjM, 35);
+       ext_grs_edge_t *e_pos2_52_1900 = ext_grs_act_add_edge_to_keep(pattern, "pos2_52_1900", 1, n_MultipleAdd5679_1873, n_Load605_1872, 21, e_pos2_52);
+       ext_grs_edge_t *e_e25_1901 = ext_grs_act_add_edge_to_keep(pattern, "e25_1901", ext_grs_NO_EDGE_POS, n_Const552_1866, n_MultipleAdd5687_1857, 22, e_e25);
+       ext_grs_edge_t *e_pos1_24_1902 = ext_grs_act_add_edge_to_keep(pattern, "pos1_24_1902", 0, n_Load560_1855, n_Proj561_1853, 23, e_pos1_24);
+       ext_grs_edge_t *e_pos1_29_1903 = ext_grs_act_add_edge_to_keep(pattern, "pos1_29_1903", 0, n_Load575_1868, n_Proj576_1864, 24, e_pos1_29);
+       ext_grs_edge_t *e_pos2_46_1904 = ext_grs_act_add_edge_to_keep(pattern, "pos2_46_1904", 1, n_MultipleAdd5681_1860, n_Load590_1875, 25, e_pos2_46);
+       ext_grs_edge_t *e_pos1_60_1905 = ext_grs_act_add_edge(pattern, "pos1_60_1905", 0, n_Vector_op_ProjData, n_VProj24_1867, 36);
+       ext_grs_edge_t *e_e28_1906 = ext_grs_act_add_edge_to_keep(pattern, "e28_1906", ext_grs_NO_EDGE_POS, n_IR_node5689_1871, n_MultipleAdd5687_1857, 26, e_e28);
+       ext_grs_edge_t *e_e27_1907 = ext_grs_act_add_edge_to_keep(pattern, "e27_1907", ext_grs_NO_EDGE_POS, n_IR_node5688_1874, n_MultipleAdd5687_1857, 27, e_e27);
+       ext_grs_edge_t *e_e26_1908 = ext_grs_act_add_edge_to_keep(pattern, "e26_1908", ext_grs_NO_EDGE_POS, n_Arg_0_1861, n_MultipleAdd5687_1857, 28, e_e26);
+       ext_grs_edge_t *e_pos1_63_1909 = ext_grs_act_add_edge(pattern, "pos1_63_1909", 0, n_Vector_op_ProjData, n_VProj30_1865, 37);
+       ext_grs_edge_t *e_pos1_62_1910 = ext_grs_act_add_edge(pattern, "pos1_62_1910", 0, n_Vector_op_ProjData, n_VProj28_1870, 38);
+       ext_grs_edge_t *e_pos1_61_1911 = ext_grs_act_add_edge(pattern, "pos1_61_1911", 0, n_Vector_op_ProjData, n_VProj26_1856, 39);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_32226);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_32229);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_32232);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_32235);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_32238);
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_32241);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vload_4f_32_variant2 */
+
+
+/* functions for evaluation of conditions of action vstore_4f_variant0 */
+static int grs_cond_func_44474(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[0/* VProj3987 */]) == 0;
+}
+static int grs_cond_func_44477(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[2/* VProj4017 */]) == 2;
+}
+static int grs_cond_func_44480(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[5/* VProj4032 */]) == 3;
+}
+static int grs_cond_func_44483(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[3/* Const4028 */])) == 12;
+}
+static int grs_cond_func_44486(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[19/* Const4013 */])) == 8;
+}
+static int grs_cond_func_44489(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj4009 */]) == 0;
+}
+static int grs_cond_func_44492(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[21/* MultipleAdd5824 */]) == 2;
+}
+static int grs_cond_func_44495(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[18/* VProj4002 */]) == 1;
+}
+static int grs_cond_func_44498(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[20/* MultipleAdd5826 */]) == 2;
+}
+static int grs_cond_func_44501(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[8/* MultipleAdd5831 */]) == 2;
+}
+static int grs_cond_func_44504(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[6/* MultipleAdd5828 */]) == 2;
+}
+static int grs_cond_func_44507(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[16/* Proj3994 */]) == 0;
+}
+static int grs_cond_func_44510(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[9/* Const5830 */])) == 0;
+}
+static int grs_cond_func_44513(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Proj4024 */]) == 0;
+}
+static int grs_cond_func_44516(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[1/* Proj4039 */]) == 0;
+}
+
+static void *grs_eval_out_func_44659(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[22/* Vector_op_ProjM */], 0);
+  return(NULL);
+}
+/* functions for building the pattern of action vstore_4f_variant0 */
+static _inline ext_grs_action_t *grs_action_vstore_4f_variant0_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vstore_4f_variant0");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_VProj3987 = ext_grs_act_add_node(pattern, "VProj3987", grs_op_VProj, mode_F, 0);
+    ext_grs_node_t *n_Proj4039 = ext_grs_act_add_node(pattern, "Proj4039", grs_op_Proj, mode_M, 1);
+    ext_grs_node_t *n_VProj4017 = ext_grs_act_add_node(pattern, "VProj4017", grs_op_VProj, mode_F, 2);
+    ext_grs_node_t *n_Const4028 = ext_grs_act_add_node(pattern, "Const4028", grs_op_Const, mode_Is, 3);
+    ext_grs_node_t *n_Store3993 = ext_grs_act_add_node(pattern, "Store3993", grs_op_Store, mode_T, 4);
+    ext_grs_node_t *n_VProj4032 = ext_grs_act_add_node(pattern, "VProj4032", grs_op_VProj, mode_F, 5);
+    ext_grs_node_t *n_MultipleAdd5828 = ext_grs_act_add_node(pattern, "MultipleAdd5828", grs_op_MultipleAdd, mode_P, 6);
+    ext_grs_node_t *n_Store4038 = ext_grs_act_add_node(pattern, "Store4038", grs_op_Store, mode_T, 7);
+    ext_grs_node_t *n_MultipleAdd5831 = ext_grs_act_add_node(pattern, "MultipleAdd5831", grs_op_MultipleAdd, mode_P, 8);
+    ext_grs_node_t *n_Const5830 = ext_grs_act_add_node(pattern, "Const5830", grs_op_Const, mode_Is, 9);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 10);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 11);
+    ext_grs_node_t *n_Store4023 = ext_grs_act_add_node(pattern, "Store4023", grs_op_Store, mode_T, 12);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 13);
+    ext_grs_node_t *n_Store4008 = ext_grs_act_add_node(pattern, "Store4008", grs_op_Store, mode_T, 14);
+    ext_grs_node_t *n_Proj4024 = ext_grs_act_add_node(pattern, "Proj4024", grs_op_Proj, mode_M, 15);
+    ext_grs_node_t *n_Proj3994 = ext_grs_act_add_node(pattern, "Proj3994", grs_op_Proj, mode_M, 16);
+    ext_grs_node_t *n_Proj4009 = ext_grs_act_add_node(pattern, "Proj4009", grs_op_Proj, mode_M, 17);
+    ext_grs_node_t *n_VProj4002 = ext_grs_act_add_node(pattern, "VProj4002", grs_op_VProj, mode_F, 18);
+    ext_grs_node_t *n_Const4013 = ext_grs_act_add_node(pattern, "Const4013", grs_op_Const, mode_Is, 19);
+    ext_grs_node_t *n_MultipleAdd5826 = ext_grs_act_add_node(pattern, "MultipleAdd5826", grs_op_MultipleAdd, mode_P, 20);
+    ext_grs_node_t *n_MultipleAdd5824 = ext_grs_act_add_node(pattern, "MultipleAdd5824", grs_op_MultipleAdd, mode_P, 21);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_30 = ext_grs_act_add_edge(pattern, "pos1_30", 0, n_Arg_0, n_VProj4032, 0);
+    ext_grs_edge_t *e_pos1_31 = ext_grs_act_add_edge(pattern, "pos1_31", 0, n_Store4008, n_Proj4009, 1);
+    ext_grs_edge_t *e_pos0_32 = ext_grs_act_add_edge(pattern, "pos0_32", -1, n_Vector_op_Block, n_Store4008, 2);
+    ext_grs_edge_t *e_e35 = ext_grs_act_add_edge(pattern, "e35", ext_grs_NO_EDGE_POS, n_Const4028, n_MultipleAdd5824, 3);
+    ext_grs_edge_t *e_e36 = ext_grs_act_add_edge(pattern, "e36", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5824, 4);
+    ext_grs_edge_t *e_pos1_37 = ext_grs_act_add_edge(pattern, "pos1_37", 0, n_Arg_0, n_VProj4002, 5);
+    ext_grs_edge_t *e_pos2_33 = ext_grs_act_add_edge(pattern, "pos2_33", 1, n_MultipleAdd5828, n_Store4008, 6);
+    ext_grs_edge_t *e_e38 = ext_grs_act_add_edge(pattern, "e38", ext_grs_NO_EDGE_POS, n_Const4013, n_MultipleAdd5826, 7);
+    ext_grs_edge_t *e_e39 = ext_grs_act_add_edge(pattern, "e39", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5826, 8);
+    ext_grs_edge_t *e_pos0_23 = ext_grs_act_add_edge(pattern, "pos0_23", -1, n_Vector_op_Block, n_Store4023, 9);
+    ext_grs_edge_t *e_e42 = ext_grs_act_add_edge(pattern, "e42", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5828, 10);
+    ext_grs_edge_t *e_e40 = ext_grs_act_add_edge(pattern, "e40", ext_grs_NO_EDGE_POS, n_Const5830, n_MultipleAdd5831, 11);
+    ext_grs_edge_t *e_pos0_26 = ext_grs_act_add_edge(pattern, "pos0_26", -1, n_Vector_op_Block, n_Store4038, 12);
+    ext_grs_edge_t *e_e41 = ext_grs_act_add_edge(pattern, "e41", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5831, 13);
+    ext_grs_edge_t *e_pos1_47 = ext_grs_act_add_edge(pattern, "pos1_47", 0, n_Store4023, n_Proj4024, 14);
+    ext_grs_edge_t *e_pos1_48 = ext_grs_act_add_edge(pattern, "pos1_48", 0, n_Store4038, n_Proj4039, 15);
+    ext_grs_edge_t *e_pos1_43 = ext_grs_act_add_edge(pattern, "pos1_43", 0, n_Store3993, n_Proj3994, 16);
+    ext_grs_edge_t *e_pos3_28 = ext_grs_act_add_edge(pattern, "pos3_28", 2, n_VProj4032, n_Store4038, 17);
+    ext_grs_edge_t *e_pos2_24 = ext_grs_act_add_edge(pattern, "pos2_24", 1, n_MultipleAdd5826, n_Store4023, 18);
+    ext_grs_edge_t *e_pos2_27 = ext_grs_act_add_edge(pattern, "pos2_27", 1, n_MultipleAdd5824, n_Store4038, 19);
+    ext_grs_edge_t *e_pos3_25 = ext_grs_act_add_edge(pattern, "pos3_25", 2, n_VProj4017, n_Store4023, 20);
+    ext_grs_edge_t *e_pos3_34 = ext_grs_act_add_edge(pattern, "pos3_34", 2, n_VProj4002, n_Store4008, 21);
+    ext_grs_edge_t *e_pos1_22 = ext_grs_act_add_edge(pattern, "pos1_22", 0, n_Arg_0, n_VProj3987, 22);
+    ext_grs_edge_t *e_pos0_44 = ext_grs_act_add_edge(pattern, "pos0_44", -1, n_Vector_op_Block, n_Store3993, 23);
+    ext_grs_edge_t *e_pos1_29 = ext_grs_act_add_edge(pattern, "pos1_29", 0, n_Arg_0, n_VProj4017, 24);
+    ext_grs_edge_t *e_pos2_45 = ext_grs_act_add_edge(pattern, "pos2_45", 1, n_MultipleAdd5831, n_Store3993, 25);
+    ext_grs_edge_t *e_pos3_46 = ext_grs_act_add_edge(pattern, "pos3_46", 2, n_VProj3987, n_Store3993, 26);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3987};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44474, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4017};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44477, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4032};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44480, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const4028};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44483, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const4013};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44486, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4009};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44489, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5824};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44492, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4002};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44495, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5826};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44498, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5831};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44501, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5828};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44504, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3994};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44507, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const5830};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44510, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4024};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44513, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4039};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44516, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_VProj3987_1912 = ext_grs_act_add_node_to_keep(pattern, "VProj3987_1912", grs_op_VProj, mode_F, 0, n_VProj3987);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 22);
+       ext_grs_node_t *n_Sync29_1913 = ext_grs_act_add_node_to_keep(pattern, "Sync29_1913", grs_op_Sync, mode_M, 23, n_Proj4039);
+       ext_grs_node_t *n_VProj4017_1914 = ext_grs_act_add_node_to_keep(pattern, "VProj4017_1914", grs_op_VProj, mode_F, 2, n_VProj4017);
+       ext_grs_node_t *n_Const4028_1915 = ext_grs_act_add_node_to_keep(pattern, "Const4028_1915", grs_op_Const, mode_Is, 3, n_Const4028);
+       ext_grs_node_t *n_Sync27_1916 = ext_grs_act_add_node_to_keep(pattern, "Sync27_1916", grs_op_Sync, mode_M, 24, n_Store3993);
+       ext_grs_node_t *n_VProj4032_1917 = ext_grs_act_add_node_to_keep(pattern, "VProj4032_1917", grs_op_VProj, mode_F, 5, n_VProj4032);
+       ext_grs_node_t *n_MultipleAdd5828_1918 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5828_1918", grs_op_MultipleAdd, mode_P, 6, n_MultipleAdd5828);
+       ext_grs_node_t *n_Sync23_1919 = ext_grs_act_add_node_to_keep(pattern, "Sync23_1919", grs_op_Sync, mode_M, 25, n_Store4038);
+       ext_grs_node_t *n_MultipleAdd5831_1920 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5831_1920", grs_op_MultipleAdd, mode_P, 8, n_MultipleAdd5831);
+       ext_grs_node_t *n_Const5830_1921 = ext_grs_act_add_node_to_keep(pattern, "Const5830_1921", grs_op_Const, mode_Is, 9, n_Const5830);
+       ext_grs_node_t *n_Arg_0_1922 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1922", grs_op_VectorBase, mode_ANY, 10, n_Arg_0);
+       ext_grs_node_t *n_Arg_1_1923 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_1923", grs_op_VectorBase, mode_ANY, 11, n_Arg_1);
+       ext_grs_node_t *n_Sync22_1924 = ext_grs_act_add_node_to_keep(pattern, "Sync22_1924", grs_op_Sync, mode_M, 26, n_Store4023);
+       ext_grs_node_t *n_Bad22 = ext_grs_act_add_node(pattern, "Bad22", grs_op_Bad, mode_ANY, 27);
+       ext_grs_node_t *n_Vector_op_Block_1925 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1925", grs_op_Block, mode_BB, 13, n_Vector_op_Block);
+       ext_grs_node_t *n_Sync25_1926 = ext_grs_act_add_node_to_keep(pattern, "Sync25_1926", grs_op_Sync, mode_M, 28, n_Store4008);
+       ext_grs_node_t *n_Sync28_1927 = ext_grs_act_add_node_to_keep(pattern, "Sync28_1927", grs_op_Sync, mode_M, 29, n_Proj4024);
+       ext_grs_node_t *n_Sync26_1928 = ext_grs_act_add_node_to_keep(pattern, "Sync26_1928", grs_op_Sync, mode_M, 30, n_Proj3994);
+       ext_grs_node_t *n_Sync24_1929 = ext_grs_act_add_node_to_keep(pattern, "Sync24_1929", grs_op_Sync, mode_M, 31, n_Proj4009);
+       ext_grs_node_t *n_VProj4002_1930 = ext_grs_act_add_node_to_keep(pattern, "VProj4002_1930", grs_op_VProj, mode_F, 18, n_VProj4002);
+       ext_grs_node_t *n_Const4013_1931 = ext_grs_act_add_node_to_keep(pattern, "Const4013_1931", grs_op_Const, mode_Is, 19, n_Const4013);
+       ext_grs_node_t *n_MultipleAdd5826_1932 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5826_1932", grs_op_MultipleAdd, mode_P, 20, n_MultipleAdd5826);
+       ext_grs_node_t *n_MultipleAdd5824_1933 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5824_1933", grs_op_MultipleAdd, mode_P, 21, n_MultipleAdd5824);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 32);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_30_1934 = ext_grs_act_add_edge_to_keep(pattern, "pos1_30_1934", 0, n_Arg_0_1922, n_VProj4032_1917, 0, e_pos1_30);
+       ext_grs_edge_t *e_pos1_31_1935 = ext_grs_act_add_edge_to_keep(pattern, "pos1_31_1935", 0, n_Sync25_1926, n_Sync24_1929, 1, e_pos1_31);
+       ext_grs_edge_t *e_e35_1936 = ext_grs_act_add_edge_to_keep(pattern, "e35_1936", ext_grs_NO_EDGE_POS, n_Const4028_1915, n_MultipleAdd5824_1933, 3, e_e35);
+       ext_grs_edge_t *e_pos0_32_1937 = ext_grs_act_add_edge_to_keep(pattern, "pos0_32_1937", -1, n_Vector_op_Block_1925, n_Sync25_1926, 2, e_pos0_32);
+       ext_grs_edge_t *e_e36_1938 = ext_grs_act_add_edge_to_keep(pattern, "e36_1938", ext_grs_NO_EDGE_POS, n_Arg_1_1923, n_MultipleAdd5824_1933, 4, e_e36);
+       ext_grs_edge_t *e_pos1_37_1939 = ext_grs_act_add_edge_to_keep(pattern, "pos1_37_1939", 0, n_Arg_0_1922, n_VProj4002_1930, 5, e_pos1_37);
+       ext_grs_edge_t *e_pos3_52_1940 = ext_grs_act_add_edge(pattern, "pos3_52_1940", 2, n_Bad22, n_Vector_op, 27);
+       ext_grs_edge_t *e_e38_1941 = ext_grs_act_add_edge_to_keep(pattern, "e38_1941", ext_grs_NO_EDGE_POS, n_Const4013_1931, n_MultipleAdd5826_1932, 7, e_e38);
+       ext_grs_edge_t *e_e39_1942 = ext_grs_act_add_edge_to_keep(pattern, "e39_1942", ext_grs_NO_EDGE_POS, n_Arg_1_1923, n_MultipleAdd5826_1932, 8, e_e39);
+       ext_grs_edge_t *e_pos0_23_1943 = ext_grs_act_add_edge_to_keep(pattern, "pos0_23_1943", -1, n_Vector_op_Block_1925, n_Sync22_1924, 9, e_pos0_23);
+       ext_grs_edge_t *e_e42_1944 = ext_grs_act_add_edge_to_keep(pattern, "e42_1944", ext_grs_NO_EDGE_POS, n_Arg_1_1923, n_MultipleAdd5828_1918, 10, e_e42);
+       ext_grs_edge_t *e_e40_1945 = ext_grs_act_add_edge_to_keep(pattern, "e40_1945", ext_grs_NO_EDGE_POS, n_Const5830_1921, n_MultipleAdd5831_1920, 11, e_e40);
+       ext_grs_edge_t *e_pos0_26_1946 = ext_grs_act_add_edge_to_keep(pattern, "pos0_26_1946", -1, n_Vector_op_Block_1925, n_Sync23_1919, 12, e_pos0_26);
+       ext_grs_edge_t *e_e41_1947 = ext_grs_act_add_edge_to_keep(pattern, "e41_1947", ext_grs_NO_EDGE_POS, n_Arg_1_1923, n_MultipleAdd5831_1920, 13, e_e41);
+       ext_grs_edge_t *e_pos1_47_1948 = ext_grs_act_add_edge_to_keep(pattern, "pos1_47_1948", 0, n_Sync22_1924, n_Sync28_1927, 14, e_pos1_47);
+       ext_grs_edge_t *e_pos1_48_1949 = ext_grs_act_add_edge_to_keep(pattern, "pos1_48_1949", 0, n_Sync23_1919, n_Sync29_1913, 15, e_pos1_48);
+       ext_grs_edge_t *e_pos1_43_1950 = ext_grs_act_add_edge_to_keep(pattern, "pos1_43_1950", 0, n_Sync27_1916, n_Sync26_1928, 16, e_pos1_43);
+       ext_grs_edge_t *e_pos0_54_1951 = ext_grs_act_add_edge(pattern, "pos0_54_1951", -1, n_Vector_op_Block_1925, n_Vector_op_ProjM, 28);
+       ext_grs_edge_t *e_pos1_51_1952 = ext_grs_act_add_edge(pattern, "pos1_51_1952", 0, n_Arg_0_1922, n_Vector_op, 29);
+       ext_grs_edge_t *e_pos2_50_1953 = ext_grs_act_add_edge(pattern, "pos2_50_1953", 1, n_MultipleAdd5831_1920, n_Vector_op, 30);
+       ext_grs_edge_t *e_pos1_53_1954 = ext_grs_act_add_edge(pattern, "pos1_53_1954", 0, n_Vector_op, n_Vector_op_ProjM, 31);
+       ext_grs_edge_t *e_pos1_22_1955 = ext_grs_act_add_edge_to_keep(pattern, "pos1_22_1955", 0, n_Arg_0_1922, n_VProj3987_1912, 22, e_pos1_22);
+       ext_grs_edge_t *e_pos0_49_1956 = ext_grs_act_add_edge(pattern, "pos0_49_1956", -1, n_Vector_op_Block_1925, n_Vector_op, 32);
+       ext_grs_edge_t *e_pos0_44_1957 = ext_grs_act_add_edge_to_keep(pattern, "pos0_44_1957", -1, n_Vector_op_Block_1925, n_Sync27_1916, 23, e_pos0_44);
+       ext_grs_edge_t *e_pos1_29_1958 = ext_grs_act_add_edge_to_keep(pattern, "pos1_29_1958", 0, n_Arg_0_1922, n_VProj4017_1914, 24, e_pos1_29);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_44659);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vstore_4f_variant0 */
+
+
+/* functions for evaluation of conditions of action vstore_4f_variant1 */
+static int grs_cond_func_44913(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[0/* VProj3987 */]) == 0;
+}
+static int grs_cond_func_44916(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[2/* VProj4017 */]) == 2;
+}
+static int grs_cond_func_44919(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[5/* VProj4032 */]) == 3;
+}
+static int grs_cond_func_44922(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[3/* Const4028 */])) == 12;
+}
+static int grs_cond_func_44925(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[19/* Const4013 */])) == 8;
+}
+static int grs_cond_func_44928(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj4009 */]) == 0;
+}
+static int grs_cond_func_44931(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[21/* MultipleAdd5824 */]) == 3;
+}
+static int grs_cond_func_44934(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[18/* VProj4002 */]) == 1;
+}
+static int grs_cond_func_44937(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[20/* MultipleAdd5826 */]) == 3;
+}
+static int grs_cond_func_44940(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[8/* MultipleAdd5831 */]) == 3;
+}
+static int grs_cond_func_44943(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[6/* MultipleAdd5828 */]) == 3;
+}
+static int grs_cond_func_44946(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[16/* Proj3994 */]) == 0;
+}
+static int grs_cond_func_44949(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[9/* Const5830 */])) == 0;
+}
+static int grs_cond_func_44952(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Proj4024 */]) == 0;
+}
+static int grs_cond_func_44955(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[1/* Proj4039 */]) == 0;
+}
+
+static void *grs_eval_out_func_45104(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[23/* Vector_op_ProjM */], 0);
+  return(NULL);
+}
+/* functions for building the pattern of action vstore_4f_variant1 */
+static _inline ext_grs_action_t *grs_action_vstore_4f_variant1_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vstore_4f_variant1");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_VProj3987 = ext_grs_act_add_node(pattern, "VProj3987", grs_op_VProj, mode_F, 0);
+    ext_grs_node_t *n_Proj4039 = ext_grs_act_add_node(pattern, "Proj4039", grs_op_Proj, mode_M, 1);
+    ext_grs_node_t *n_VProj4017 = ext_grs_act_add_node(pattern, "VProj4017", grs_op_VProj, mode_F, 2);
+    ext_grs_node_t *n_Const4028 = ext_grs_act_add_node(pattern, "Const4028", grs_op_Const, mode_Is, 3);
+    ext_grs_node_t *n_Store3993 = ext_grs_act_add_node(pattern, "Store3993", grs_op_Store, mode_T, 4);
+    ext_grs_node_t *n_VProj4032 = ext_grs_act_add_node(pattern, "VProj4032", grs_op_VProj, mode_F, 5);
+    ext_grs_node_t *n_MultipleAdd5828 = ext_grs_act_add_node(pattern, "MultipleAdd5828", grs_op_MultipleAdd, mode_P, 6);
+    ext_grs_node_t *n_Store4038 = ext_grs_act_add_node(pattern, "Store4038", grs_op_Store, mode_T, 7);
+    ext_grs_node_t *n_MultipleAdd5831 = ext_grs_act_add_node(pattern, "MultipleAdd5831", grs_op_MultipleAdd, mode_P, 8);
+    ext_grs_node_t *n_Const5830 = ext_grs_act_add_node(pattern, "Const5830", grs_op_Const, mode_Is, 9);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 10);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 11);
+    ext_grs_node_t *n_Store4023 = ext_grs_act_add_node(pattern, "Store4023", grs_op_Store, mode_T, 12);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 13);
+    ext_grs_node_t *n_Store4008 = ext_grs_act_add_node(pattern, "Store4008", grs_op_Store, mode_T, 14);
+    ext_grs_node_t *n_Proj4024 = ext_grs_act_add_node(pattern, "Proj4024", grs_op_Proj, mode_M, 15);
+    ext_grs_node_t *n_Proj3994 = ext_grs_act_add_node(pattern, "Proj3994", grs_op_Proj, mode_M, 16);
+    ext_grs_node_t *n_Proj4009 = ext_grs_act_add_node(pattern, "Proj4009", grs_op_Proj, mode_M, 17);
+    ext_grs_node_t *n_VProj4002 = ext_grs_act_add_node(pattern, "VProj4002", grs_op_VProj, mode_F, 18);
+    ext_grs_node_t *n_Const4013 = ext_grs_act_add_node(pattern, "Const4013", grs_op_Const, mode_Is, 19);
+    ext_grs_node_t *n_MultipleAdd5826 = ext_grs_act_add_node(pattern, "MultipleAdd5826", grs_op_MultipleAdd, mode_P, 20);
+    ext_grs_node_t *n_MultipleAdd5824 = ext_grs_act_add_node(pattern, "MultipleAdd5824", grs_op_MultipleAdd, mode_P, 21);
+    ext_grs_node_t *n_IR_node5834 = ext_grs_act_add_node(pattern, "IR_node5834", grs_op_IR_node, mode_ANY, 22);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos1_30 = ext_grs_act_add_edge(pattern, "pos1_30", 0, n_Arg_0, n_VProj4017, 0);
+    ext_grs_edge_t *e_pos1_31 = ext_grs_act_add_edge(pattern, "pos1_31", 0, n_Arg_0, n_VProj4032, 1);
+    ext_grs_edge_t *e_pos0_33 = ext_grs_act_add_edge(pattern, "pos0_33", -1, n_Vector_op_Block, n_Store4008, 2);
+    ext_grs_edge_t *e_e36 = ext_grs_act_add_edge(pattern, "e36", ext_grs_NO_EDGE_POS, n_Const4028, n_MultipleAdd5824, 3);
+    ext_grs_edge_t *e_pos1_39 = ext_grs_act_add_edge(pattern, "pos1_39", 0, n_Arg_0, n_VProj4002, 4);
+    ext_grs_edge_t *e_pos1_32 = ext_grs_act_add_edge(pattern, "pos1_32", 0, n_Store4008, n_Proj4009, 5);
+    ext_grs_edge_t *e_pos2_34 = ext_grs_act_add_edge(pattern, "pos2_34", 1, n_MultipleAdd5828, n_Store4008, 6);
+    ext_grs_edge_t *e_pos3_51 = ext_grs_act_add_edge(pattern, "pos3_51", 2, n_VProj3987, n_Store3993, 7);
+    ext_grs_edge_t *e_e38 = ext_grs_act_add_edge(pattern, "e38", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5824, 8);
+    ext_grs_edge_t *e_e37 = ext_grs_act_add_edge(pattern, "e37", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5824, 9);
+    ext_grs_edge_t *e_e46 = ext_grs_act_add_edge(pattern, "e46", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5828, 10);
+    ext_grs_edge_t *e_e47 = ext_grs_act_add_edge(pattern, "e47", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5828, 11);
+    ext_grs_edge_t *e_e44 = ext_grs_act_add_edge(pattern, "e44", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5831, 12);
+    ext_grs_edge_t *e_e45 = ext_grs_act_add_edge(pattern, "e45", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5831, 13);
+    ext_grs_edge_t *e_e42 = ext_grs_act_add_edge(pattern, "e42", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5826, 14);
+    ext_grs_edge_t *e_pos0_24 = ext_grs_act_add_edge(pattern, "pos0_24", -1, n_Vector_op_Block, n_Store4023, 15);
+    ext_grs_edge_t *e_e43 = ext_grs_act_add_edge(pattern, "e43", ext_grs_NO_EDGE_POS, n_Const5830, n_MultipleAdd5831, 16);
+    ext_grs_edge_t *e_pos0_27 = ext_grs_act_add_edge(pattern, "pos0_27", -1, n_Vector_op_Block, n_Store4038, 17);
+    ext_grs_edge_t *e_e40 = ext_grs_act_add_edge(pattern, "e40", ext_grs_NO_EDGE_POS, n_Const4013, n_MultipleAdd5826, 18);
+    ext_grs_edge_t *e_e41 = ext_grs_act_add_edge(pattern, "e41", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5826, 19);
+    ext_grs_edge_t *e_pos1_48 = ext_grs_act_add_edge(pattern, "pos1_48", 0, n_Store3993, n_Proj3994, 20);
+    ext_grs_edge_t *e_pos2_25 = ext_grs_act_add_edge(pattern, "pos2_25", 1, n_MultipleAdd5826, n_Store4023, 21);
+    ext_grs_edge_t *e_pos3_29 = ext_grs_act_add_edge(pattern, "pos3_29", 2, n_VProj4032, n_Store4038, 22);
+    ext_grs_edge_t *e_pos3_26 = ext_grs_act_add_edge(pattern, "pos3_26", 2, n_VProj4017, n_Store4023, 23);
+    ext_grs_edge_t *e_pos2_28 = ext_grs_act_add_edge(pattern, "pos2_28", 1, n_MultipleAdd5824, n_Store4038, 24);
+    ext_grs_edge_t *e_pos3_35 = ext_grs_act_add_edge(pattern, "pos3_35", 2, n_VProj4002, n_Store4008, 25);
+    ext_grs_edge_t *e_pos2_50 = ext_grs_act_add_edge(pattern, "pos2_50", 1, n_MultipleAdd5831, n_Store3993, 26);
+    ext_grs_edge_t *e_pos1_53 = ext_grs_act_add_edge(pattern, "pos1_53", 0, n_Store4038, n_Proj4039, 27);
+    ext_grs_edge_t *e_pos1_52 = ext_grs_act_add_edge(pattern, "pos1_52", 0, n_Store4023, n_Proj4024, 28);
+    ext_grs_edge_t *e_pos1_23 = ext_grs_act_add_edge(pattern, "pos1_23", 0, n_Arg_0, n_VProj3987, 29);
+    ext_grs_edge_t *e_pos0_49 = ext_grs_act_add_edge(pattern, "pos0_49", -1, n_Vector_op_Block, n_Store3993, 30);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3987};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44913, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4017};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44916, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4032};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44919, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const4028};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44922, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const4013};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44925, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4009};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44928, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5824};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44931, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4002};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44934, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5826};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44937, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5831};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44940, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5828};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44943, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3994};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44946, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const5830};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44949, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4024};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44952, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4039};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_44955, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_VProj3987_1959 = ext_grs_act_add_node_to_keep(pattern, "VProj3987_1959", grs_op_VProj, mode_F, 0, n_VProj3987);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 23);
+       ext_grs_node_t *n_Sync30_1960 = ext_grs_act_add_node_to_keep(pattern, "Sync30_1960", grs_op_Sync, mode_M, 24, n_Proj4039);
+       ext_grs_node_t *n_VProj4017_1961 = ext_grs_act_add_node_to_keep(pattern, "VProj4017_1961", grs_op_VProj, mode_F, 2, n_VProj4017);
+       ext_grs_node_t *n_Const4028_1962 = ext_grs_act_add_node_to_keep(pattern, "Const4028_1962", grs_op_Const, mode_Is, 3, n_Const4028);
+       ext_grs_node_t *n_Sync28_1963 = ext_grs_act_add_node_to_keep(pattern, "Sync28_1963", grs_op_Sync, mode_M, 25, n_Store3993);
+       ext_grs_node_t *n_VProj4032_1964 = ext_grs_act_add_node_to_keep(pattern, "VProj4032_1964", grs_op_VProj, mode_F, 5, n_VProj4032);
+       ext_grs_node_t *n_MultipleAdd5828_1965 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5828_1965", grs_op_MultipleAdd, mode_P, 6, n_MultipleAdd5828);
+       ext_grs_node_t *n_Sync24_1966 = ext_grs_act_add_node_to_keep(pattern, "Sync24_1966", grs_op_Sync, mode_M, 26, n_Store4038);
+       ext_grs_node_t *n_MultipleAdd5831_1967 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5831_1967", grs_op_MultipleAdd, mode_P, 8, n_MultipleAdd5831);
+       ext_grs_node_t *n_Const5830_1968 = ext_grs_act_add_node_to_keep(pattern, "Const5830_1968", grs_op_Const, mode_Is, 9, n_Const5830);
+       ext_grs_node_t *n_Arg_0_1969 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_1969", grs_op_VectorBase, mode_ANY, 10, n_Arg_0);
+       ext_grs_node_t *n_Arg_1_1970 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_1970", grs_op_VectorBase, mode_ANY, 11, n_Arg_1);
+       ext_grs_node_t *n_Sync23_1971 = ext_grs_act_add_node_to_keep(pattern, "Sync23_1971", grs_op_Sync, mode_M, 27, n_Store4023);
+       ext_grs_node_t *n_Bad23 = ext_grs_act_add_node(pattern, "Bad23", grs_op_Bad, mode_ANY, 28);
+       ext_grs_node_t *n_Vector_op_Block_1972 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_1972", grs_op_Block, mode_BB, 13, n_Vector_op_Block);
+       ext_grs_node_t *n_Sync26_1973 = ext_grs_act_add_node_to_keep(pattern, "Sync26_1973", grs_op_Sync, mode_M, 29, n_Store4008);
+       ext_grs_node_t *n_Sync29_1974 = ext_grs_act_add_node_to_keep(pattern, "Sync29_1974", grs_op_Sync, mode_M, 30, n_Proj4024);
+       ext_grs_node_t *n_Sync27_1975 = ext_grs_act_add_node_to_keep(pattern, "Sync27_1975", grs_op_Sync, mode_M, 31, n_Proj3994);
+       ext_grs_node_t *n_Sync25_1976 = ext_grs_act_add_node_to_keep(pattern, "Sync25_1976", grs_op_Sync, mode_M, 32, n_Proj4009);
+       ext_grs_node_t *n_VProj4002_1977 = ext_grs_act_add_node_to_keep(pattern, "VProj4002_1977", grs_op_VProj, mode_F, 18, n_VProj4002);
+       ext_grs_node_t *n_Const4013_1978 = ext_grs_act_add_node_to_keep(pattern, "Const4013_1978", grs_op_Const, mode_Is, 19, n_Const4013);
+       ext_grs_node_t *n_MultipleAdd5826_1979 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5826_1979", grs_op_MultipleAdd, mode_P, 20, n_MultipleAdd5826);
+       ext_grs_node_t *n_MultipleAdd5824_1980 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5824_1980", grs_op_MultipleAdd, mode_P, 21, n_MultipleAdd5824);
+       ext_grs_node_t *n_IR_node5834_1981 = ext_grs_act_add_node_to_keep(pattern, "IR_node5834_1981", grs_op_IR_node, mode_ANY, 22, n_IR_node5834);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 33);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos1_30_1982 = ext_grs_act_add_edge_to_keep(pattern, "pos1_30_1982", 0, n_Arg_0_1969, n_VProj4017_1961, 0, e_pos1_30);
+       ext_grs_edge_t *e_pos0_33_1983 = ext_grs_act_add_edge_to_keep(pattern, "pos0_33_1983", -1, n_Vector_op_Block_1972, n_Sync26_1973, 2, e_pos0_33);
+       ext_grs_edge_t *e_pos1_31_1984 = ext_grs_act_add_edge_to_keep(pattern, "pos1_31_1984", 0, n_Arg_0_1969, n_VProj4032_1964, 1, e_pos1_31);
+       ext_grs_edge_t *e_e36_1985 = ext_grs_act_add_edge_to_keep(pattern, "e36_1985", ext_grs_NO_EDGE_POS, n_Const4028_1962, n_MultipleAdd5824_1980, 3, e_e36);
+       ext_grs_edge_t *e_pos1_39_1986 = ext_grs_act_add_edge_to_keep(pattern, "pos1_39_1986", 0, n_Arg_0_1969, n_VProj4002_1977, 4, e_pos1_39);
+       ext_grs_edge_t *e_pos1_32_1987 = ext_grs_act_add_edge_to_keep(pattern, "pos1_32_1987", 0, n_Sync26_1973, n_Sync25_1976, 5, e_pos1_32);
+       ext_grs_edge_t *e_e38_1988 = ext_grs_act_add_edge_to_keep(pattern, "e38_1988", ext_grs_NO_EDGE_POS, n_IR_node5834_1981, n_MultipleAdd5824_1980, 8, e_e38);
+       ext_grs_edge_t *e_e37_1989 = ext_grs_act_add_edge_to_keep(pattern, "e37_1989", ext_grs_NO_EDGE_POS, n_Arg_1_1970, n_MultipleAdd5824_1980, 9, e_e37);
+       ext_grs_edge_t *e_pos3_57_1990 = ext_grs_act_add_edge(pattern, "pos3_57_1990", 2, n_Bad23, n_Vector_op, 31);
+       ext_grs_edge_t *e_e46_1991 = ext_grs_act_add_edge_to_keep(pattern, "e46_1991", ext_grs_NO_EDGE_POS, n_Arg_1_1970, n_MultipleAdd5828_1965, 10, e_e46);
+       ext_grs_edge_t *e_e47_1992 = ext_grs_act_add_edge_to_keep(pattern, "e47_1992", ext_grs_NO_EDGE_POS, n_IR_node5834_1981, n_MultipleAdd5828_1965, 11, e_e47);
+       ext_grs_edge_t *e_e44_1993 = ext_grs_act_add_edge_to_keep(pattern, "e44_1993", ext_grs_NO_EDGE_POS, n_Arg_1_1970, n_MultipleAdd5831_1967, 12, e_e44);
+       ext_grs_edge_t *e_e45_1994 = ext_grs_act_add_edge_to_keep(pattern, "e45_1994", ext_grs_NO_EDGE_POS, n_IR_node5834_1981, n_MultipleAdd5831_1967, 13, e_e45);
+       ext_grs_edge_t *e_e42_1995 = ext_grs_act_add_edge_to_keep(pattern, "e42_1995", ext_grs_NO_EDGE_POS, n_IR_node5834_1981, n_MultipleAdd5826_1979, 14, e_e42);
+       ext_grs_edge_t *e_pos0_24_1996 = ext_grs_act_add_edge_to_keep(pattern, "pos0_24_1996", -1, n_Vector_op_Block_1972, n_Sync23_1971, 15, e_pos0_24);
+       ext_grs_edge_t *e_e43_1997 = ext_grs_act_add_edge_to_keep(pattern, "e43_1997", ext_grs_NO_EDGE_POS, n_Const5830_1968, n_MultipleAdd5831_1967, 16, e_e43);
+       ext_grs_edge_t *e_pos0_27_1998 = ext_grs_act_add_edge_to_keep(pattern, "pos0_27_1998", -1, n_Vector_op_Block_1972, n_Sync24_1966, 17, e_pos0_27);
+       ext_grs_edge_t *e_e40_1999 = ext_grs_act_add_edge_to_keep(pattern, "e40_1999", ext_grs_NO_EDGE_POS, n_Const4013_1978, n_MultipleAdd5826_1979, 18, e_e40);
+       ext_grs_edge_t *e_e41_2000 = ext_grs_act_add_edge_to_keep(pattern, "e41_2000", ext_grs_NO_EDGE_POS, n_Arg_1_1970, n_MultipleAdd5826_1979, 19, e_e41);
+       ext_grs_edge_t *e_pos1_48_2001 = ext_grs_act_add_edge_to_keep(pattern, "pos1_48_2001", 0, n_Sync28_1963, n_Sync27_1975, 20, e_pos1_48);
+       ext_grs_edge_t *e_pos0_59_2002 = ext_grs_act_add_edge(pattern, "pos0_59_2002", -1, n_Vector_op_Block_1972, n_Vector_op_ProjM, 32);
+       ext_grs_edge_t *e_pos0_54_2003 = ext_grs_act_add_edge(pattern, "pos0_54_2003", -1, n_Vector_op_Block_1972, n_Vector_op, 33);
+       ext_grs_edge_t *e_pos1_56_2004 = ext_grs_act_add_edge(pattern, "pos1_56_2004", 0, n_Arg_0_1969, n_Vector_op, 34);
+       ext_grs_edge_t *e_pos1_58_2005 = ext_grs_act_add_edge(pattern, "pos1_58_2005", 0, n_Vector_op, n_Vector_op_ProjM, 35);
+       ext_grs_edge_t *e_pos2_55_2006 = ext_grs_act_add_edge(pattern, "pos2_55_2006", 1, n_MultipleAdd5831_1967, n_Vector_op, 36);
+       ext_grs_edge_t *e_pos1_53_2007 = ext_grs_act_add_edge_to_keep(pattern, "pos1_53_2007", 0, n_Sync24_1966, n_Sync30_1960, 27, e_pos1_53);
+       ext_grs_edge_t *e_pos1_52_2008 = ext_grs_act_add_edge_to_keep(pattern, "pos1_52_2008", 0, n_Sync23_1971, n_Sync29_1974, 28, e_pos1_52);
+       ext_grs_edge_t *e_pos1_23_2009 = ext_grs_act_add_edge_to_keep(pattern, "pos1_23_2009", 0, n_Arg_0_1969, n_VProj3987_1959, 29, e_pos1_23);
+       ext_grs_edge_t *e_pos0_49_2010 = ext_grs_act_add_edge_to_keep(pattern, "pos0_49_2010", -1, n_Vector_op_Block_1972, n_Sync28_1963, 30, e_pos0_49);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_45104);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vstore_4f_variant1 */
+
+
+/* functions for evaluation of conditions of action vstore_4f_variant2 */
+static int grs_cond_func_45376(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[0/* VProj3987 */]) == 0;
+}
+static int grs_cond_func_45379(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[2/* VProj4017 */]) == 2;
+}
+static int grs_cond_func_45382(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[5/* VProj4032 */]) == 3;
+}
+static int grs_cond_func_45385(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[3/* Const4028 */])) == 12;
+}
+static int grs_cond_func_45388(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[19/* Const4013 */])) == 8;
+}
+static int grs_cond_func_45391(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[17/* Proj4009 */]) == 0;
+}
+static int grs_cond_func_45394(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[21/* MultipleAdd5824 */]) == 4;
+}
+static int grs_cond_func_45397(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_VProj_proj(node_map[18/* VProj4002 */]) == 1;
+}
+static int grs_cond_func_45400(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[20/* MultipleAdd5826 */]) == 4;
+}
+static int grs_cond_func_45403(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[8/* MultipleAdd5831 */]) == 4;
+}
+static int grs_cond_func_45406(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_irn_arity(node_map[6/* MultipleAdd5828 */]) == 4;
+}
+static int grs_cond_func_45409(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[16/* Proj3994 */]) == 0;
+}
+static int grs_cond_func_45412(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_tarval_long(get_Const_tarval(node_map[9/* Const5830 */])) == 0;
+}
+static int grs_cond_func_45415(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[15/* Proj4024 */]) == 0;
+}
+static int grs_cond_func_45418(ir_node **node_map, const ir_edge_t **edge_map) {
+  return get_Proj_proj(node_map[1/* Proj4039 */]) == 0;
+}
+
+static void *grs_eval_out_func_45573(ir_node **rpl_node_map, const ir_edge_t **rpl_edge_map, ir_node **pat_node_map, void *data) {
+  set_Proj_proj(rpl_node_map[24/* Vector_op_ProjM */], 0);
+  return(NULL);
+}
+/* functions for building the pattern of action vstore_4f_variant2 */
+static _inline ext_grs_action_t *grs_action_vstore_4f_variant2_init() {
+  ext_grs_action_t *act = ext_grs_new_action(ext_grs_k_rule, "vstore_4f_variant2");
+  int check;
+  { /* The action */
+    ext_grs_graph_t *pattern = ext_grs_act_get_pattern(act);
+
+    /* The nodes of the pattern */
+    ext_grs_node_t *n_VProj3987 = ext_grs_act_add_node(pattern, "VProj3987", grs_op_VProj, mode_F, 0);
+    ext_grs_node_t *n_Proj4039 = ext_grs_act_add_node(pattern, "Proj4039", grs_op_Proj, mode_M, 1);
+    ext_grs_node_t *n_VProj4017 = ext_grs_act_add_node(pattern, "VProj4017", grs_op_VProj, mode_F, 2);
+    ext_grs_node_t *n_Const4028 = ext_grs_act_add_node(pattern, "Const4028", grs_op_Const, mode_Is, 3);
+    ext_grs_node_t *n_Store3993 = ext_grs_act_add_node(pattern, "Store3993", grs_op_Store, mode_T, 4);
+    ext_grs_node_t *n_VProj4032 = ext_grs_act_add_node(pattern, "VProj4032", grs_op_VProj, mode_F, 5);
+    ext_grs_node_t *n_MultipleAdd5828 = ext_grs_act_add_node(pattern, "MultipleAdd5828", grs_op_MultipleAdd, mode_P, 6);
+    ext_grs_node_t *n_Store4038 = ext_grs_act_add_node(pattern, "Store4038", grs_op_Store, mode_T, 7);
+    ext_grs_node_t *n_MultipleAdd5831 = ext_grs_act_add_node(pattern, "MultipleAdd5831", grs_op_MultipleAdd, mode_P, 8);
+    ext_grs_node_t *n_Const5830 = ext_grs_act_add_node(pattern, "Const5830", grs_op_Const, mode_Is, 9);
+    ext_grs_node_t *n_Arg_0 = ext_grs_act_add_node(pattern, "Arg_0", grs_op_VectorBase, mode_ANY, 10);
+    ext_grs_node_t *n_Arg_1 = ext_grs_act_add_node(pattern, "Arg_1", grs_op_VectorBase, mode_ANY, 11);
+    ext_grs_node_t *n_Store4023 = ext_grs_act_add_node(pattern, "Store4023", grs_op_Store, mode_T, 12);
+    ext_grs_node_t *n_Vector_op_Block = ext_grs_act_add_node(pattern, "Vector_op_Block", grs_op_Block, mode_BB, 13);
+    ext_grs_node_t *n_Store4008 = ext_grs_act_add_node(pattern, "Store4008", grs_op_Store, mode_T, 14);
+    ext_grs_node_t *n_Proj4024 = ext_grs_act_add_node(pattern, "Proj4024", grs_op_Proj, mode_M, 15);
+    ext_grs_node_t *n_Proj3994 = ext_grs_act_add_node(pattern, "Proj3994", grs_op_Proj, mode_M, 16);
+    ext_grs_node_t *n_Proj4009 = ext_grs_act_add_node(pattern, "Proj4009", grs_op_Proj, mode_M, 17);
+    ext_grs_node_t *n_VProj4002 = ext_grs_act_add_node(pattern, "VProj4002", grs_op_VProj, mode_F, 18);
+    ext_grs_node_t *n_Const4013 = ext_grs_act_add_node(pattern, "Const4013", grs_op_Const, mode_Is, 19);
+    ext_grs_node_t *n_MultipleAdd5826 = ext_grs_act_add_node(pattern, "MultipleAdd5826", grs_op_MultipleAdd, mode_P, 20);
+    ext_grs_node_t *n_MultipleAdd5824 = ext_grs_act_add_node(pattern, "MultipleAdd5824", grs_op_MultipleAdd, mode_P, 21);
+    ext_grs_node_t *n_IR_node5835 = ext_grs_act_add_node(pattern, "IR_node5835", grs_op_IR_node, mode_ANY, 22);
+    ext_grs_node_t *n_IR_node5834 = ext_grs_act_add_node(pattern, "IR_node5834", grs_op_IR_node, mode_ANY, 23);
+
+    /* The edges of the pattern */
+    ext_grs_edge_t *e_pos0_34 = ext_grs_act_add_edge(pattern, "pos0_34", -1, n_Vector_op_Block, n_Store4008, 0);
+    ext_grs_edge_t *e_pos1_31 = ext_grs_act_add_edge(pattern, "pos1_31", 0, n_Arg_0, n_VProj4017, 1);
+    ext_grs_edge_t *e_pos1_32 = ext_grs_act_add_edge(pattern, "pos1_32", 0, n_Arg_0, n_VProj4032, 2);
+    ext_grs_edge_t *e_pos1_33 = ext_grs_act_add_edge(pattern, "pos1_33", 0, n_Store4008, n_Proj4009, 3);
+    ext_grs_edge_t *e_pos2_35 = ext_grs_act_add_edge(pattern, "pos2_35", 1, n_MultipleAdd5828, n_Store4008, 4);
+    ext_grs_edge_t *e_e38 = ext_grs_act_add_edge(pattern, "e38", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5824, 5);
+    ext_grs_edge_t *e_e37 = ext_grs_act_add_edge(pattern, "e37", ext_grs_NO_EDGE_POS, n_Const4028, n_MultipleAdd5824, 6);
+    ext_grs_edge_t *e_pos3_56 = ext_grs_act_add_edge(pattern, "pos3_56", 2, n_VProj3987, n_Store3993, 7);
+    ext_grs_edge_t *e_e39 = ext_grs_act_add_edge(pattern, "e39", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5824, 8);
+    ext_grs_edge_t *e_e46 = ext_grs_act_add_edge(pattern, "e46", ext_grs_NO_EDGE_POS, n_Const5830, n_MultipleAdd5831, 9);
+    ext_grs_edge_t *e_e47 = ext_grs_act_add_edge(pattern, "e47", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5831, 10);
+    ext_grs_edge_t *e_pos1_41 = ext_grs_act_add_edge(pattern, "pos1_41", 0, n_Arg_0, n_VProj4002, 11);
+    ext_grs_edge_t *e_e44 = ext_grs_act_add_edge(pattern, "e44", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5826, 12);
+    ext_grs_edge_t *e_e45 = ext_grs_act_add_edge(pattern, "e45", ext_grs_NO_EDGE_POS, n_IR_node5835, n_MultipleAdd5826, 13);
+    ext_grs_edge_t *e_pos0_25 = ext_grs_act_add_edge(pattern, "pos0_25", -1, n_Vector_op_Block, n_Store4023, 14);
+    ext_grs_edge_t *e_e42 = ext_grs_act_add_edge(pattern, "e42", ext_grs_NO_EDGE_POS, n_Const4013, n_MultipleAdd5826, 15);
+    ext_grs_edge_t *e_e43 = ext_grs_act_add_edge(pattern, "e43", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5826, 16);
+    ext_grs_edge_t *e_e40 = ext_grs_act_add_edge(pattern, "e40", ext_grs_NO_EDGE_POS, n_IR_node5835, n_MultipleAdd5824, 17);
+    ext_grs_edge_t *e_pos3_27 = ext_grs_act_add_edge(pattern, "pos3_27", 2, n_VProj4017, n_Store4023, 18);
+    ext_grs_edge_t *e_pos2_26 = ext_grs_act_add_edge(pattern, "pos2_26", 1, n_MultipleAdd5826, n_Store4023, 19);
+    ext_grs_edge_t *e_pos2_29 = ext_grs_act_add_edge(pattern, "pos2_29", 1, n_MultipleAdd5824, n_Store4038, 20);
+    ext_grs_edge_t *e_pos0_28 = ext_grs_act_add_edge(pattern, "pos0_28", -1, n_Vector_op_Block, n_Store4038, 21);
+    ext_grs_edge_t *e_e49 = ext_grs_act_add_edge(pattern, "e49", ext_grs_NO_EDGE_POS, n_IR_node5835, n_MultipleAdd5831, 22);
+    ext_grs_edge_t *e_e48 = ext_grs_act_add_edge(pattern, "e48", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5831, 23);
+    ext_grs_edge_t *e_e50 = ext_grs_act_add_edge(pattern, "e50", ext_grs_NO_EDGE_POS, n_Arg_1, n_MultipleAdd5828, 24);
+    ext_grs_edge_t *e_e52 = ext_grs_act_add_edge(pattern, "e52", ext_grs_NO_EDGE_POS, n_IR_node5835, n_MultipleAdd5828, 25);
+    ext_grs_edge_t *e_e51 = ext_grs_act_add_edge(pattern, "e51", ext_grs_NO_EDGE_POS, n_IR_node5834, n_MultipleAdd5828, 26);
+    ext_grs_edge_t *e_pos0_54 = ext_grs_act_add_edge(pattern, "pos0_54", -1, n_Vector_op_Block, n_Store3993, 27);
+    ext_grs_edge_t *e_pos1_57 = ext_grs_act_add_edge(pattern, "pos1_57", 0, n_Store4023, n_Proj4024, 28);
+    ext_grs_edge_t *e_pos1_58 = ext_grs_act_add_edge(pattern, "pos1_58", 0, n_Store4038, n_Proj4039, 29);
+    ext_grs_edge_t *e_pos2_55 = ext_grs_act_add_edge(pattern, "pos2_55", 1, n_MultipleAdd5831, n_Store3993, 30);
+    ext_grs_edge_t *e_pos3_30 = ext_grs_act_add_edge(pattern, "pos3_30", 2, n_VProj4032, n_Store4038, 31);
+    ext_grs_edge_t *e_pos3_36 = ext_grs_act_add_edge(pattern, "pos3_36", 2, n_VProj4002, n_Store4008, 32);
+    ext_grs_edge_t *e_pos1_53 = ext_grs_act_add_edge(pattern, "pos1_53", 0, n_Store3993, n_Proj3994, 33);
+    ext_grs_edge_t *e_pos1_24 = ext_grs_act_add_edge(pattern, "pos1_24", 0, n_Arg_0, n_VProj3987, 34);
+
+    /* The conditions of the pattern */
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj3987};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45376, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4017};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45379, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4032};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45382, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const4028};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45385, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const4013};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45388, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4009};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45391, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5824};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45394, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_VProj4002};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45397, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5826};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45400, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5831};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45403, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_MultipleAdd5828};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45406, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj3994};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45409, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Const5830};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45412, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4024};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45415, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    { /* if */
+      ext_grs_node_t *nodes[1] = {n_Proj4039};
+      ext_grs_edge_t **edges = NULL;
+
+      ext_grs_act_register_condition(grs_cond_func_45418, pattern, 1, nodes, 0, edges);
+    } /* if */
+
+    /* The negative parts of the pattern */
+
+
+    { /* The replacement */
+       ext_grs_graph_t *pattern = ext_grs_act_get_replacement(act);
+
+       /* The nodes of the pattern */
+       ext_grs_node_t *n_VProj3987_2011 = ext_grs_act_add_node_to_keep(pattern, "VProj3987_2011", grs_op_VProj, mode_F, 0, n_VProj3987);
+       ext_grs_node_t *n_Vector_op_ProjM = ext_grs_act_add_node(pattern, "Vector_op_ProjM", grs_op_Proj, mode_M, 24);
+       ext_grs_node_t *n_Sync31_2012 = ext_grs_act_add_node_to_keep(pattern, "Sync31_2012", grs_op_Sync, mode_M, 25, n_Proj4039);
+       ext_grs_node_t *n_VProj4017_2013 = ext_grs_act_add_node_to_keep(pattern, "VProj4017_2013", grs_op_VProj, mode_F, 2, n_VProj4017);
+       ext_grs_node_t *n_Const4028_2014 = ext_grs_act_add_node_to_keep(pattern, "Const4028_2014", grs_op_Const, mode_Is, 3, n_Const4028);
+       ext_grs_node_t *n_Sync29_2015 = ext_grs_act_add_node_to_keep(pattern, "Sync29_2015", grs_op_Sync, mode_M, 26, n_Store3993);
+       ext_grs_node_t *n_VProj4032_2016 = ext_grs_act_add_node_to_keep(pattern, "VProj4032_2016", grs_op_VProj, mode_F, 5, n_VProj4032);
+       ext_grs_node_t *n_MultipleAdd5828_2017 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5828_2017", grs_op_MultipleAdd, mode_P, 6, n_MultipleAdd5828);
+       ext_grs_node_t *n_Sync25_2018 = ext_grs_act_add_node_to_keep(pattern, "Sync25_2018", grs_op_Sync, mode_M, 27, n_Store4038);
+       ext_grs_node_t *n_MultipleAdd5831_2019 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5831_2019", grs_op_MultipleAdd, mode_P, 8, n_MultipleAdd5831);
+       ext_grs_node_t *n_Const5830_2020 = ext_grs_act_add_node_to_keep(pattern, "Const5830_2020", grs_op_Const, mode_Is, 9, n_Const5830);
+       ext_grs_node_t *n_Bad24 = ext_grs_act_add_node(pattern, "Bad24", grs_op_Bad, mode_ANY, 28);
+       ext_grs_node_t *n_Arg_0_2021 = ext_grs_act_add_node_to_keep(pattern, "Arg_0_2021", grs_op_VectorBase, mode_ANY, 10, n_Arg_0);
+       ext_grs_node_t *n_Arg_1_2022 = ext_grs_act_add_node_to_keep(pattern, "Arg_1_2022", grs_op_VectorBase, mode_ANY, 11, n_Arg_1);
+       ext_grs_node_t *n_Sync24_2023 = ext_grs_act_add_node_to_keep(pattern, "Sync24_2023", grs_op_Sync, mode_M, 29, n_Store4023);
+       ext_grs_node_t *n_Vector_op_Block_2024 = ext_grs_act_add_node_to_keep(pattern, "Vector_op_Block_2024", grs_op_Block, mode_BB, 13, n_Vector_op_Block);
+       ext_grs_node_t *n_Sync27_2025 = ext_grs_act_add_node_to_keep(pattern, "Sync27_2025", grs_op_Sync, mode_M, 30, n_Store4008);
+       ext_grs_node_t *n_Sync30_2026 = ext_grs_act_add_node_to_keep(pattern, "Sync30_2026", grs_op_Sync, mode_M, 31, n_Proj4024);
+       ext_grs_node_t *n_Sync28_2027 = ext_grs_act_add_node_to_keep(pattern, "Sync28_2027", grs_op_Sync, mode_M, 32, n_Proj3994);
+       ext_grs_node_t *n_Sync26_2028 = ext_grs_act_add_node_to_keep(pattern, "Sync26_2028", grs_op_Sync, mode_M, 33, n_Proj4009);
+       ext_grs_node_t *n_VProj4002_2029 = ext_grs_act_add_node_to_keep(pattern, "VProj4002_2029", grs_op_VProj, mode_F, 18, n_VProj4002);
+       ext_grs_node_t *n_Const4013_2030 = ext_grs_act_add_node_to_keep(pattern, "Const4013_2030", grs_op_Const, mode_Is, 19, n_Const4013);
+       ext_grs_node_t *n_MultipleAdd5826_2031 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5826_2031", grs_op_MultipleAdd, mode_P, 20, n_MultipleAdd5826);
+       ext_grs_node_t *n_MultipleAdd5824_2032 = ext_grs_act_add_node_to_keep(pattern, "MultipleAdd5824_2032", grs_op_MultipleAdd, mode_P, 21, n_MultipleAdd5824);
+       ext_grs_node_t *n_IR_node5835_2033 = ext_grs_act_add_node_to_keep(pattern, "IR_node5835_2033", grs_op_IR_node, mode_ANY, 22, n_IR_node5835);
+       ext_grs_node_t *n_IR_node5834_2034 = ext_grs_act_add_node_to_keep(pattern, "IR_node5834_2034", grs_op_IR_node, mode_ANY, 23, n_IR_node5834);
+       ext_grs_node_t *n_Vector_op = ext_grs_act_add_node(pattern, "Vector_op", grs_op_Complex, mode_T, 34);
+
+       /* The edges of the pattern */
+       ext_grs_edge_t *e_pos0_34_2035 = ext_grs_act_add_edge_to_keep(pattern, "pos0_34_2035", -1, n_Vector_op_Block_2024, n_Sync27_2025, 0, e_pos0_34);
+       ext_grs_edge_t *e_pos1_31_2036 = ext_grs_act_add_edge_to_keep(pattern, "pos1_31_2036", 0, n_Arg_0_2021, n_VProj4017_2013, 1, e_pos1_31);
+       ext_grs_edge_t *e_pos1_32_2037 = ext_grs_act_add_edge_to_keep(pattern, "pos1_32_2037", 0, n_Arg_0_2021, n_VProj4032_2016, 2, e_pos1_32);
+       ext_grs_edge_t *e_pos1_33_2038 = ext_grs_act_add_edge_to_keep(pattern, "pos1_33_2038", 0, n_Sync27_2025, n_Sync26_2028, 3, e_pos1_33);
+       ext_grs_edge_t *e_e38_2039 = ext_grs_act_add_edge_to_keep(pattern, "e38_2039", ext_grs_NO_EDGE_POS, n_Arg_1_2022, n_MultipleAdd5824_2032, 5, e_e38);
+       ext_grs_edge_t *e_e37_2040 = ext_grs_act_add_edge_to_keep(pattern, "e37_2040", ext_grs_NO_EDGE_POS, n_Const4028_2014, n_MultipleAdd5824_2032, 6, e_e37);
+       ext_grs_edge_t *e_e39_2041 = ext_grs_act_add_edge_to_keep(pattern, "e39_2041", ext_grs_NO_EDGE_POS, n_IR_node5834_2034, n_MultipleAdd5824_2032, 8, e_e39);
+       ext_grs_edge_t *e_e46_2042 = ext_grs_act_add_edge_to_keep(pattern, "e46_2042", ext_grs_NO_EDGE_POS, n_Const5830_2020, n_MultipleAdd5831_2019, 9, e_e46);
+       ext_grs_edge_t *e_e47_2043 = ext_grs_act_add_edge_to_keep(pattern, "e47_2043", ext_grs_NO_EDGE_POS, n_Arg_1_2022, n_MultipleAdd5831_2019, 10, e_e47);
+       ext_grs_edge_t *e_pos1_41_2044 = ext_grs_act_add_edge_to_keep(pattern, "pos1_41_2044", 0, n_Arg_0_2021, n_VProj4002_2029, 11, e_pos1_41);
+       ext_grs_edge_t *e_e44_2045 = ext_grs_act_add_edge_to_keep(pattern, "e44_2045", ext_grs_NO_EDGE_POS, n_IR_node5834_2034, n_MultipleAdd5826_2031, 12, e_e44);
+       ext_grs_edge_t *e_e45_2046 = ext_grs_act_add_edge_to_keep(pattern, "e45_2046", ext_grs_NO_EDGE_POS, n_IR_node5835_2033, n_MultipleAdd5826_2031, 13, e_e45);
+       ext_grs_edge_t *e_pos0_25_2047 = ext_grs_act_add_edge_to_keep(pattern, "pos0_25_2047", -1, n_Vector_op_Block_2024, n_Sync24_2023, 14, e_pos0_25);
+       ext_grs_edge_t *e_e42_2048 = ext_grs_act_add_edge_to_keep(pattern, "e42_2048", ext_grs_NO_EDGE_POS, n_Const4013_2030, n_MultipleAdd5826_2031, 15, e_e42);
+       ext_grs_edge_t *e_e43_2049 = ext_grs_act_add_edge_to_keep(pattern, "e43_2049", ext_grs_NO_EDGE_POS, n_Arg_1_2022, n_MultipleAdd5826_2031, 16, e_e43);
+       ext_grs_edge_t *e_e40_2050 = ext_grs_act_add_edge_to_keep(pattern, "e40_2050", ext_grs_NO_EDGE_POS, n_IR_node5835_2033, n_MultipleAdd5824_2032, 17, e_e40);
+       ext_grs_edge_t *e_pos0_64_2051 = ext_grs_act_add_edge(pattern, "pos0_64_2051", -1, n_Vector_op_Block_2024, n_Vector_op_ProjM, 35);
+       ext_grs_edge_t *e_pos2_60_2052 = ext_grs_act_add_edge(pattern, "pos2_60_2052", 1, n_MultipleAdd5831_2019, n_Vector_op, 36);
+       ext_grs_edge_t *e_pos3_62_2053 = ext_grs_act_add_edge(pattern, "pos3_62_2053", 2, n_Bad24, n_Vector_op, 37);
+       ext_grs_edge_t *e_pos0_28_2054 = ext_grs_act_add_edge_to_keep(pattern, "pos0_28_2054", -1, n_Vector_op_Block_2024, n_Sync25_2018, 21, e_pos0_28);
+       ext_grs_edge_t *e_e49_2055 = ext_grs_act_add_edge_to_keep(pattern, "e49_2055", ext_grs_NO_EDGE_POS, n_IR_node5835_2033, n_MultipleAdd5831_2019, 22, e_e49);
+       ext_grs_edge_t *e_e48_2056 = ext_grs_act_add_edge_to_keep(pattern, "e48_2056", ext_grs_NO_EDGE_POS, n_IR_node5834_2034, n_MultipleAdd5831_2019, 23, e_e48);
+       ext_grs_edge_t *e_e50_2057 = ext_grs_act_add_edge_to_keep(pattern, "e50_2057", ext_grs_NO_EDGE_POS, n_Arg_1_2022, n_MultipleAdd5828_2017, 24, e_e50);
+       ext_grs_edge_t *e_e52_2058 = ext_grs_act_add_edge_to_keep(pattern, "e52_2058", ext_grs_NO_EDGE_POS, n_IR_node5835_2033, n_MultipleAdd5828_2017, 25, e_e52);
+       ext_grs_edge_t *e_pos0_59_2059 = ext_grs_act_add_edge(pattern, "pos0_59_2059", -1, n_Vector_op_Block_2024, n_Vector_op, 38);
+       ext_grs_edge_t *e_e51_2060 = ext_grs_act_add_edge_to_keep(pattern, "e51_2060", ext_grs_NO_EDGE_POS, n_IR_node5834_2034, n_MultipleAdd5828_2017, 26, e_e51);
+       ext_grs_edge_t *e_pos0_54_2061 = ext_grs_act_add_edge_to_keep(pattern, "pos0_54_2061", -1, n_Vector_op_Block_2024, n_Sync29_2015, 27, e_pos0_54);
+       ext_grs_edge_t *e_pos1_57_2062 = ext_grs_act_add_edge_to_keep(pattern, "pos1_57_2062", 0, n_Sync24_2023, n_Sync30_2026, 28, e_pos1_57);
+       ext_grs_edge_t *e_pos1_58_2063 = ext_grs_act_add_edge_to_keep(pattern, "pos1_58_2063", 0, n_Sync25_2018, n_Sync31_2012, 29, e_pos1_58);
+       ext_grs_edge_t *e_pos1_53_2064 = ext_grs_act_add_edge_to_keep(pattern, "pos1_53_2064", 0, n_Sync29_2015, n_Sync28_2027, 33, e_pos1_53);
+       ext_grs_edge_t *e_pos1_24_2065 = ext_grs_act_add_edge_to_keep(pattern, "pos1_24_2065", 0, n_Arg_0_2021, n_VProj3987_2011, 34, e_pos1_24);
+       ext_grs_edge_t *e_pos1_63_2066 = ext_grs_act_add_edge(pattern, "pos1_63_2066", 0, n_Vector_op, n_Vector_op_ProjM, 39);
+       ext_grs_edge_t *e_pos1_61_2067 = ext_grs_act_add_edge(pattern, "pos1_61_2067", 0, n_Arg_0_2021, n_Vector_op, 40);
+
+    } /* The replacement */
+
+    /* Eval functions */
+    ext_grs_act_register_eval(act, NULL, (ext_grs_eval_out_func_t) &grs_eval_out_func_45573);
+  } /* The Action */
+
+  check = ext_grs_act_mature(act);
+  assert(check);
+  return act;
+} /* vstore_4f_variant2 */
+
+
+/* global variables containing the actions */
+ext_grs_action_t *ext_grs_action_complex_instructions_add_horz_4_32_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_component_0Iu_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_component_0f_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_maxps_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_mulps_4_32_am_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_mulps_4_32_am_variant1;
+ext_grs_action_t *ext_grs_action_complex_instructions_mulps_4_32_am_variant2;
+ext_grs_action_t *ext_grs_action_complex_instructions_mulps_4_32_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_psadbw_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_vload_16b_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_vload_16b_variant1;
+ext_grs_action_t *ext_grs_action_complex_instructions_vload_16b_variant2;
+ext_grs_action_t *ext_grs_action_complex_instructions_vload_4f_32_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_vload_4f_32_variant1;
+ext_grs_action_t *ext_grs_action_complex_instructions_vload_4f_32_variant2;
+ext_grs_action_t *ext_grs_action_complex_instructions_vstore_4f_variant0;
+ext_grs_action_t *ext_grs_action_complex_instructions_vstore_4f_variant1;
+ext_grs_action_t *ext_grs_action_complex_instructions_vstore_4f_variant2;
+
+/* function for initializing the actions */
+ext_grs_action_init_complex_instructions() {
+  init();
+  ext_grs_action_complex_instructions_add_horz_4_32_variant0 = grs_action_add_horz_4_32_variant0_init();
+  ext_grs_action_complex_instructions_component_0Iu_variant0 = grs_action_component_0Iu_variant0_init();
+  ext_grs_action_complex_instructions_component_0f_variant0 = grs_action_component_0f_variant0_init();
+  ext_grs_action_complex_instructions_maxps_variant0 = grs_action_maxps_variant0_init();
+  ext_grs_action_complex_instructions_mulps_4_32_am_variant0 = grs_action_mulps_4_32_am_variant0_init();
+  ext_grs_action_complex_instructions_mulps_4_32_am_variant1 = grs_action_mulps_4_32_am_variant1_init();
+  ext_grs_action_complex_instructions_mulps_4_32_am_variant2 = grs_action_mulps_4_32_am_variant2_init();
+  ext_grs_action_complex_instructions_mulps_4_32_variant0 = grs_action_mulps_4_32_variant0_init();
+  ext_grs_action_complex_instructions_psadbw_variant0 = grs_action_psadbw_variant0_init();
+  ext_grs_action_complex_instructions_vload_16b_variant0 = grs_action_vload_16b_variant0_init();
+  ext_grs_action_complex_instructions_vload_16b_variant1 = grs_action_vload_16b_variant1_init();
+  ext_grs_action_complex_instructions_vload_16b_variant2 = grs_action_vload_16b_variant2_init();
+  ext_grs_action_complex_instructions_vload_4f_32_variant0 = grs_action_vload_4f_32_variant0_init();
+  ext_grs_action_complex_instructions_vload_4f_32_variant1 = grs_action_vload_4f_32_variant1_init();
+  ext_grs_action_complex_instructions_vload_4f_32_variant2 = grs_action_vload_4f_32_variant2_init();
+  ext_grs_action_complex_instructions_vstore_4f_variant0 = grs_action_vstore_4f_variant0_init();
+  ext_grs_action_complex_instructions_vstore_4f_variant1 = grs_action_vstore_4f_variant1_init();
+  ext_grs_action_complex_instructions_vstore_4f_variant2 = grs_action_vstore_4f_variant2_init();
+
+  /* establish inherritance */
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_store, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_store, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_store, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_store, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_store, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Entity, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Entity, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_End, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_End, grs_op_Special);
+  ext_grs_appoint_heir(grs_op_End, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_End, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Union, grs_op_Compound);
+  ext_grs_appoint_heir(grs_op_Union, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Union, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Union, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_sse, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_sse, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_sse, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_sse, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_addr_sse, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Special, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Struct, grs_op_Compound);
+  ext_grs_appoint_heir(grs_op_Struct, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Struct, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Struct, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Memory, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Complex, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Complex, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Complex, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_sse, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_sse, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_sse, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_sse, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_sse, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Tarval, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Tarval, grs_op_Node);
+
+
+  ext_grs_appoint_heir(grs_op_V2Load, grs_op_V2);
+  ext_grs_appoint_heir(grs_op_V2Load, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V2Load, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V2Load, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_V2Load, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V2Sub, grs_op_V2);
+  ext_grs_appoint_heir(grs_op_V2Sub, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V2Sub, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V2Sub, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_V2Sub, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IR_node, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IR_node, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_CMOV, grs_op_IntrinsicGP);
+  ext_grs_appoint_heir(grs_op_CMOV, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_CMOV, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_CMOV, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_CMOV, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_CMOV, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Match, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_SymConst, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_SymConst, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_SymConst, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_SymConst, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Store, grs_op_MemNode);
+  ext_grs_appoint_heir(grs_op_Store, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Store, grs_op_Memory);
+  ext_grs_appoint_heir(grs_op_Store, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Store, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Break, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Break, grs_op_Controlflow);
+  ext_grs_appoint_heir(grs_op_Break, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Break, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_pi);
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_Node);
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V4pi_2, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_pi);
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_Node);
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V4pi_1, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_pi);
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_Node);
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V4pi_4, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_V4);
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_pi);
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_Node);
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V4pi_3, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_Unary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Div, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Div, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Div, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Div, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Div, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Div, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Free, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Free, grs_op_Memory);
+  ext_grs_appoint_heir(grs_op_Free, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Free, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Trinary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicMatch, grs_op_Match);
+  ext_grs_appoint_heir(grs_op_IntrinsicMatch, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Bad, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Bad, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Bad, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Confirm, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Confirm, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Confirm, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntConst, grs_op_Const);
+  ext_grs_appoint_heir(grs_op_IntConst, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_IntConst, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_IntConst, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IntConst, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Nary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Raise, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Raise, grs_op_Controlflow);
+  ext_grs_appoint_heir(grs_op_Raise, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Raise, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Id, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Id, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Id, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Or, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Commutative);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Or, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Commutative);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Eor, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Vector, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Vector, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Vector, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_reg_sse, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_reg_sse, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_reg_sse, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_reg_sse, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_reg_sse, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Add, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Commutative);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Add, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_VProj, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_VProj, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_VProj, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_VProj, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicMMX, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_IntrinsicMMX, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicMMX, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_IntrinsicMMX, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicMMX, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Const, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Const, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Const, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Const, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Sel, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Sel, grs_op_VectorBase);
+  ext_grs_appoint_heir(grs_op_Sel, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Sel, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Sub, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Ordinary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Tuple, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Tuple, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Tuple, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_MultipleAdd, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_MultipleAdd, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_MultipleAdd, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicFP, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_IntrinsicFP, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicFP, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_IntrinsicFP, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicFP, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Cmp, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Cmp, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Cmp, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Cmp, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Commutative);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Mulh, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_And, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Commutative);
+  ext_grs_appoint_heir(grs_op_And, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_And, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Method_IRG, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Method_IRG, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_CCopy, grs_op_IntrinsicGP);
+  ext_grs_appoint_heir(grs_op_CCopy, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_CCopy, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_CCopy, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_CCopy, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_CCopy, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_EndReg, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_EndReg, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_EndReg, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Call, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Call, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Call, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Cast, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Cast, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Cast, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_EndExcept, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_EndExcept, grs_op_Controlflow);
+  ext_grs_appoint_heir(grs_op_EndExcept, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_EndExcept, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Sync, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Sync, grs_op_Memory);
+  ext_grs_appoint_heir(grs_op_Sync, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Sync, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Rot, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_NoMem, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_NoMem, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_NoMem, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Unknown, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Unknown, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Unknown, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Primitive, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Primitive, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Primitive, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicGP, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Mux, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mux, grs_op_Trinary);
+  ext_grs_appoint_heir(grs_op_Mux, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Mux, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_pi, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Quot, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Method, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Method, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Method, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Jmp, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Jmp, grs_op_Controlflow);
+  ext_grs_appoint_heir(grs_op_Jmp, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Jmp, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Commutative);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Mul, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Associative, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Start, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Start, grs_op_Special);
+  ext_grs_appoint_heir(grs_op_Start, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Start, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_SyncArity2, grs_op_Sync);
+  ext_grs_appoint_heir(grs_op_SyncArity2, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_SyncArity2, grs_op_Memory);
+  ext_grs_appoint_heir(grs_op_SyncArity2, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_SyncArity2, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Arithmetic, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Arithmetic, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_store, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_store, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_store, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_store, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_addr_store, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Conv, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Conv, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Conv, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Conv, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_VectorBase, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_VectorBase, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_VectorBase, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V2Store, grs_op_V2);
+  ext_grs_appoint_heir(grs_op_V2Store, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V2Store, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V2Store, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_V2Store, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_Controlflow);
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Cond, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Class, grs_op_Compound);
+  ext_grs_appoint_heir(grs_op_Class, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Class, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Class, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_Unary);
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Abs, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_V2);
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_pi);
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_Node);
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V2pi_1, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_Commutative, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_V2);
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_pi);
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_Node);
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V2pi_2, grs_op_FIRM_node);
+
+  ext_grs_appoint_heir(grs_op_StartBlock, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Phi, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Phi, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Phi, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Phi, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Block, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Block, grs_op_Special);
+  ext_grs_appoint_heir(grs_op_Block, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Block, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_MemNode, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_MemNode, grs_op_Memory);
+  ext_grs_appoint_heir(grs_op_MemNode, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_MemNode, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Enum, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Enum, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Enum, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Shrs, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Array, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Array, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Array, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_max, grs_op_IntrinsicGP);
+  ext_grs_appoint_heir(grs_op_max, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_max, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_max, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_max, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_max, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Proj, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Proj, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Proj, grs_op_VectorBase);
+  ext_grs_appoint_heir(grs_op_Proj, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Proj, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Mod, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Binary, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V2, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V2, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V2, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_V2, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Not, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Not, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Not, grs_op_Unary);
+  ext_grs_appoint_heir(grs_op_Not, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Not, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Not, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_V4, grs_op_Vector);
+  ext_grs_appoint_heir(grs_op_V4, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_V4, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_V4, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse_sse, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse_sse, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse_sse, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse_sse, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_sse_sse_sse, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_reg_sse_sse, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_reg_sse_sse, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_reg_sse_sse, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_reg_sse_sse, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_reg_sse_sse, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_DivMod, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_FIRM_node, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Alloc, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Alloc, grs_op_Memory);
+  ext_grs_appoint_heir(grs_op_Alloc, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Alloc, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Pointer, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Pointer, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Pointer, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_Unary);
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Minus, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Type, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Type, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Return, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Return, grs_op_Controlflow);
+  ext_grs_appoint_heir(grs_op_Return, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Return, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicSSE, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_IntrinsicSSE, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicSSE, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_IntrinsicSSE, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicSSE, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Filter, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Filter, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Filter, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Controlflow, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_min, grs_op_IntrinsicGP);
+  ext_grs_appoint_heir(grs_op_min, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_min, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_min, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_min, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_min, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse_store, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse_store, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse_store, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse_store, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Intrinsic_addr_sse_store, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Compound, grs_op_Type);
+  ext_grs_appoint_heir(grs_op_Compound, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Compound, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Load, grs_op_MemNode);
+  ext_grs_appoint_heir(grs_op_Load, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Load, grs_op_Memory);
+  ext_grs_appoint_heir(grs_op_Load, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Load, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Shl, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IgnoreCF, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_Arithmetic);
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_Binary);
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_Shr, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_InstOf, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_InstOf, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_InstOf, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IntrinsicGP3, grs_op_Intrinsic);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP3, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP3, grs_op_Ordinary);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP3, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IntrinsicGP3, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_IR_Keep, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_IR_Keep, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_IR_Keep, grs_op_Node);
+
+  ext_grs_appoint_heir(grs_op_CallBegin, grs_op_IR_node);
+  ext_grs_appoint_heir(grs_op_CallBegin, grs_op_FIRM_node);
+  ext_grs_appoint_heir(grs_op_CallBegin, grs_op_Node);
+
+  ext_grs_inheritance_mature();
+}

diff --git a/ir/be/grgen/simd/generated/node_attributes.c b/ir/be/grgen/simd/generated/node_attributes.c
new file mode 100644 (file)
index 0000000..1ad388b
--- /dev/null
+++ b/ir/be/grgen/simd/generated/node_attributes.c
@@ -0,0 +1,3 @@
+/* TODO: Dump all the nodes attributes ->
+       e.g. pointers to result nodes...
+       here */

diff --git a/ir/be/grgen/simd/generated/pattern_importer.c b/ir/be/grgen/simd/generated/pattern_importer.c
new file mode 100644 (file)
index 0000000..0bba2e8
--- /dev/null
+++ b/ir/be/grgen/simd/generated/pattern_importer.c
@@ -0,0 +1,21 @@
+/*************************************************************************
+* Program:  pattern_importer.c
+* Function: Includes all the generated patterns. This wrapper can turn off
+*                      the includation of generated patterns in case the gerenation went
+*                      wrong.
+* Author:   Andreas Schoesser
+* Date:     2007-01-09
+*************************************************************************/
+
+#include "../simd_presets.h"
+
+
+// Only include the patterns of the INCLUDE_GENERATED_PATTERNS macro
+// is set in simd_presets.h. Can be turned off in case gen_patterns.c
+// contains errors
+
+#ifdef INCLUDE_GENERATED_PATTERNS
+  #include "firm.h"
+  #include "../firm_node_ext.h"
+  #include "gen_patterns.c"
+#endif

diff --git a/ir/be/grgen/simd/grgen_dumper.c b/ir/be/grgen/simd/grgen_dumper.c
new file mode 100644 (file)
index 0000000..b6c04d2
--- /dev/null
+++ b/ir/be/grgen/simd/grgen_dumper.c
@@ -0,0 +1,1116 @@
+/*****************************************************************************
+ * Program:            grgen_dumper.c
+ * Function:   Dumps parts of a firm graph (those which have to be extracted
+ *                             as search and replace patterns) as a grGen rule.
+ * Depends on: Needs the analysis info generated by the pattern creator
+ * Author:             Andreas Schoesser
+ * Date:               2006-12-07
+ *****************************************************************************/
+
+
+// ---------------------------- INCLUDES --------------------------------
+
+#include <assert.h>
+#include <stdio.h>
+#include <obst.h>
+
+#include "simd_presets.h"
+
+#include "firm_types.h"
+#include "pmap.h"
+#include "tv.h"
+#include "irgwalk.h"
+
+#include "grgen_dumper__t.h"
+#include "create_pattern_t.h"
+#include "firm_node_ext.h"
+
+// ----------------------------- GLOABALS --------------------------------
+
+// Saves the current indent value and keeps spaces in a string
+#define MAX_INDENT 100
+static char indent[MAX_INDENT] = "";
+static int  current_indent = 0;
+
+// Saves the current node number to generate node names
+static int node_counter;
+static int edge_counter;
+
+
+
+
+/************************************************************************
+ * Initializes the grgen_dumper module and dumps the GrGen File header
+ * Returns:            An environment to be passed to all functions of the GrGen
+ *                             dumper.
+ * Parameters: file:   filename of the file to dump to
+ *                             append: 1 if the previous file content should be
+ *                                             maintained.
+ ************************************************************************/
+
+grgen_dumper_env_t *init_grgen_dumper(char *file, int append)
+{
+       grgen_dumper_env_t *grgen_dumper_env = malloc(sizeof(grgen_dumper_env_t));
+       FILE *fp;
+
+       if(append)
+               fp = fopen(file, "at");
+       else
+       {
+               fp = fopen(file, "wt");
+
+               // *** Dump header
+               fprintf(fp, "%susing Firm;\n\n", indent);
+       }
+
+       grgen_dumper_env -> output_file = fp;
+       return(grgen_dumper_env);
+}
+
+
+
+/************************************************************************
+ * Frees information used by the grgen_dumper and closes the output file
+ ************************************************************************/
+
+void deinit_grgen_dumper(grgen_dumper_env_t *grgen_dumper_env)
+{
+       fclose(grgen_dumper_env->output_file);
+       free(grgen_dumper_env);
+}
+
+
+
+
+/************************************************************************
+ * Starts dumping
+ * Returns
+ * 1 if the complex operation uses the memory edge
+ * 0 if no memory edge is used.
+ ************************************************************************/
+
+int dump_irgraph_grgen(grgen_dumper_env_t *grgen_dumper_env, graph_ana_info_t *graph_ana_info)
+{
+       FILE *fp = grgen_dumper_env -> output_file;
+       dump_info_t dump_info;
+       int uses_memory = 0;
+       char irg_name[255];
+
+       get_rule_name(graph_ana_info, irg_name);
+
+       // Do initialization
+       dump_info.irg = graph_ana_info->irg;                                                    // Basically copy the graph_ana_struct, ugly
+       dump_info.destroyed_regs = graph_ana_info->destroyed_regs;              // Should have used a pointer to the
+       dump_info.register_access = graph_ana_info->register_access;    // graph_ana_info struct here
+       dump_info.memory_access = graph_ana_info->memory_access;
+       dump_info.nodes_to_dump = graph_ana_info->nodes_to_dump;
+       dump_info.argument_nodes = graph_ana_info->argument_nodes;
+       dump_info.complex_operation_block = graph_ana_info->complex_operation_block;
+       dump_info.node_to_match_block = graph_ana_info->node_to_match_block;
+       dump_info.has_result = graph_ana_info->has_result;
+       dump_info.priority = graph_ana_info->priority;
+       dump_info.mode_edge_map = pmap_create();                // Create some additional pmaps to hold
+       dump_info.edge_name_map = pmap_create();                // node and edge name information etc.
+       dump_info.node_name_map = pmap_create();
+       dump_info.mode_name_map = pmap_create();
+       dump_info.dump_condition = pmap_create();               // pmaps "misused" as lists here...
+       dump_info.retyped_nodes = pmap_create();
+       dump_info.eval_statements = pmap_create();
+       dump_info.dump_everything = graph_ana_info->dump_everything;
+
+       // Node and egde count start at 0 for each pattern to be dumped.
+       node_counter = 0;
+       edge_counter = 0;
+       obstack_init(&(dump_info.node_names));
+       obstack_init(&(dump_info.mode_names));
+
+       // Dump rule header
+       set_indent(0);
+       fprintf(fp, "\n\n%srule %s\n%s{\n", indent, irg_name, indent);
+       set_indent(2);
+       if(!dump_info.dump_everything)
+               fprintf(fp, "%spattern\n%s{\n", indent, indent);
+       else
+       {
+               fprintf(fp, "%spattern { }\n", indent);
+               fprintf(fp, "%sreplace\n%s{\n", indent, indent);
+       }
+       set_indent(4);
+
+       // *** Dump the left side of the rule
+       uses_memory = dump_pattern(&dump_info, fp);
+
+       // *** Dump the right side of the rule
+       if(!dump_info.dump_everything)  // Hack: If a whole graph is dumped, the pattern part will raise errors since no complex operations etc. are there
+       {
+               dump_replacement(&dump_info, uses_memory, fp);
+
+               // *** Dump the eval part of the rule
+               fprintf(fp, "\n%seval {\n", indent);
+               set_indent(6);
+               dump_mandatory_evals(&dump_info, uses_memory, fp);
+               dump_vproj_nr(&dump_info, fp);  // Dumps all vproj_nr attribute assignments
+               set_indent(4);
+               fprintf(fp, "%s} /* Eval */\n", indent);
+
+               // *** Close the replacement part
+
+               set_indent(2);
+               fprintf(fp, "%s} /* Replacement */\n", indent);
+       }
+
+       // *** Dump footer
+       set_indent(0);
+       fprintf(fp, "%s}\n", indent);
+
+       // Clean up
+       pmap_destroy(dump_info.mode_edge_map);
+       pmap_destroy(dump_info.edge_name_map);
+       pmap_destroy(dump_info.node_name_map);
+       pmap_destroy(dump_info.mode_name_map);
+       pmap_destroy(dump_info.dump_condition);
+       pmap_destroy(dump_info.retyped_nodes);
+       pmap_destroy(dump_info.eval_statements);
+       obstack_free(&(dump_info.node_names), NULL);
+       obstack_finish(&(dump_info.node_names));
+       obstack_free(&(dump_info.mode_names), NULL);
+       obstack_finish(&(dump_info.mode_names));
+
+       return(uses_memory);
+}
+
+
+/************************************************************************
+ * Dumps the left hand side of the rule
+ ************************************************************************/
+
+static int dump_pattern(dump_info_t *dump_info, FILE *fp)
+{
+       struct pmap *nodes_to_dump = dump_info->nodes_to_dump;
+       pmap_entry *entry;
+       int uses_memory = 0;
+
+       // Dump all nodes
+       pmap_foreach(nodes_to_dump, entry)
+       {
+               ir_node *n = (ir_node *) entry->key;
+               ir_opcode code;
+
+               // Dump node
+               if(get_irn_opcode(n) == iro_Proj && get_irn_modecode(n) == irm_M)
+                       uses_memory = 1;
+               dump_grgen_node(n, dump_info, fp);
+               dump_grgen_mode(n, dump_info, fp, NULL);
+               //dump_grgen_block(n, dump_info, fp);
+
+
+               // If a condition has to be dumped afterwards: Save the node for later
+               code = get_irn_opcode(n);
+               if(code == iro_MultipleAdd ||
+                  code == iro_VProj ||
+                  code == iro_Const ||
+                  code == iro_Proj ||
+                  code == iro_Phi)
+                       pmap_insert(dump_info -> dump_condition, n, NULL);
+       }
+
+       // Dump all edges
+       pmap_foreach(nodes_to_dump, entry)
+       {
+               ir_node *n = (ir_node *) entry->key;
+               int i;
+
+               // Dump edges
+               for(i = -1; i < get_irn_arity(n); i++)
+                       dump_grgen_edge(n, i, dump_info, fp);
+       }
+
+       // Dump the edge from a special pattern node to it's block. This block will later be the block
+       // of the complex operation
+       //dump_complex_operation_block_match(dump_info, fp);
+
+       if(!dump_info->dump_everything)
+       {
+
+               fprintf(fp, "\n%sif\n%s{\n", indent, indent);
+               set_indent(6);
+
+               pmap_foreach(dump_info->dump_condition, entry)
+               {
+                       ir_node *n = (ir_node *) entry->key;
+                       dump_grgen_condition(n, dump_info, fp);
+               }
+               set_indent(4);
+               fprintf(fp, "%s} /* Conditions */\n", indent);
+       }
+
+       set_indent(2);
+       fprintf(fp, "%s} /* Pattern */\n", indent);
+       return(uses_memory);
+}
+
+
+
+/************************************************************************
+ * Dumps the right hand side of the rule
+ ************************************************************************/
+
+static void dump_replacement(dump_info_t *dump_info, int uses_memory, FILE *fp)
+{
+       pmap_entry *entry;
+       register_access_descr_t *register_access_descr;
+       memory_access_descr_t *memory_access_descr;
+
+       // dump grGen "replace" statement
+       fprintf(fp, "\n%smodify {\n", indent);
+       set_indent(4);
+
+       // Dump the complex operation node with it's projs and vprojs
+       dump_complex_operation(dump_info, fp, uses_memory);
+
+       // Dump the rest of the replacement nodes. Do retyping to VProj if necessary
+       fprintf(fp, "\n");
+
+       // First dump all nodes.
+       pmap_foreach(dump_info->nodes_to_dump, entry)
+       {
+               ir_node *n = (ir_node *) entry->key;
+
+               if((register_access_descr = pmap_get(dump_info->register_access, n)) != NULL)
+               {
+                       // Nodes that represent a result in a register have to be retyped
+                       if(register_access_descr -> load_store == REGISTER_STORE)
+                       {
+                               // Find out, if this store is a component of a vector or a standalone scalar
+                               argument_descr_t *arg_descr;
+
+                               arg_descr = pmap_get(dump_info->argument_nodes, register_access_descr->pointer_base);
+                               assert(arg_descr && "No argument information available! Should have been created during analysis!");
+
+                               // Treat SCALAR and VECTOR_COMPONENT differently
+                               // A vector component has to be retyped to VProj
+                               // A scalar has to be retyped to a Proj
+                               switch(arg_descr->argument_type)
+                               {
+                                       case ARGUMENT_VECTOR:
+                                                       // Not needed:
+                                                       // assert(get_irn_opcode(n) != iro_VProj); // An existing VProj would be a register LOAD
+
+                                                       // Node is a vector result to be stored in a register:
+                                                       // Retype the node to VProj
+                                                       // Connect it with the Data Proj of the complex operation
+                                                       dump_retyping_to_vproj(n, NULL, dump_info, VECTOR_OP_PROJDATA_NAME, fp);
+                                                       //dump_grgen_block(n, dump_info, fp);
+                                                       break;
+
+                                       case ARGUMENT_SCALAR:
+                                                       // Retype the scalar result to proj
+                                                       // Connect it directly with the operation
+                                                       dump_retyping_to_proj(n, NULL, dump_info, VECTOR_OP_NAME, fp);
+                                                       //dump_grgen_block(n, dump_info, fp);
+                                                       //assert(0 && "// TODO: retype_to_proj, if the result is a scalar");
+                                                       break;
+
+                                       default:
+                                                       assert(0 && "Argument Type not implemented!");
+                               }
+
+                               continue;
+                       }
+               }
+
+               if((memory_access_descr = pmap_get(dump_info->memory_access, n)) != NULL)
+               {
+                       if(memory_access_descr->load_store == MEMORY_STORE)
+                       {
+                                       // Node is part of a memory store, that is STORE or PROJM node.
+                                       // Retype it to id.
+                                       // Trick to keep the M-edge predecessor of the Store node as
+                                       // the predecessor of the Id Node without actually matching the predecessor:
+                                       // Since we don't dump the M-Edge of the STORE but the Adr and Value edges and
+                                       // we can just "not dump" the 2 matched edges. The Adr and Value edges are therefore
+                                       // killed by the graph rewriting system. The M-Edge is not specified at all and the
+                                       // GRS is supposed to leave the edge as it was. M-Edges of Stores are at position 0,
+                                       // so the kept edge is also at position 0, which is correct.
+                                       dump_grgen_retyped_node(n, op_Sync, dump_info, fp);
+                                       dump_grgen_delete_incoming_edges(n, dump_info, fp); // Only the M edge (not matched) will persist
+                                       change_mode(n, mode_M, dump_info, fp);
+                                       continue;
+                       }
+               }
+
+               // Same for the STORE PROJ M
+               if(get_irn_opcode(n) == iro_Proj && (memory_access_descr = pmap_get(dump_info->memory_access, get_irn_n(n, 0))) != NULL)
+               {
+                       if(memory_access_descr->load_store == MEMORY_STORE)
+                       {
+                               dump_grgen_retyped_node(n, op_Sync, dump_info, fp);
+                               change_mode(n, mode_M, dump_info, fp);
+                               continue;
+                       }
+               }
+       }
+
+
+       // Now dump the edges of the replaced nodes, that could not be dumped before:
+       // - Eliminated STOREs and ProjMs
+       pmap_foreach(dump_info->retyped_nodes, entry)
+       {
+               const ir_node *n = entry->key;
+               if(pmap_contains(dump_info->memory_access, n))
+               {
+                       memory_access_descr_t *memory_access_descr = pmap_get(dump_info->memory_access, n);
+                       assert(memory_access_descr->load_store == MEMORY_STORE);
+
+                       if(get_irn_opcode(n) == iro_Proj)
+                       {
+                               // dump in edge of the retyped ProjM
+                               fprintf(fp, "%s%s -:df-> %s;\n", indent, pmap_get(dump_info->node_name_map, n), pmap_get(dump_info->node_name_map, get_irn_n(n, 0)));
+                       }
+               }
+       }
+       //dump_complex_operation_block_match(dump_info, fp);
+
+       /* Don't close the replacement since evals have moved into the replacement part  */
+#if 0
+       set_indent(2);
+       fprintf(fp, "%s} /* Replacement */\n", indent);
+#endif
+}
+
+
+
+/************************************************************************
+ * Dumps the new complex operation node and it's Projs and Vprojs
+ ************************************************************************/
+
+void dump_complex_operation(dump_info_t *dump_info, FILE *fp, int uses_memory)
+{
+       pmap_entry *entry;
+       int i, mem_slot = (uses_memory) ? 1 : 0, max_argument;
+       char *mode_node_name, eval[100];
+
+       // Generate Vector operation
+       fprintf(fp, "%s%s : Complex;\n", indent, VECTOR_OP_NAME);
+
+       // Dump the mode of the Complex op (mode T).
+       mode_node_name = dump_grgen_mode_node(mode_T, dump_info, fp);
+       fprintf(fp, "%s%s -:has_mode-> %s;\n", indent, VECTOR_OP_NAME, mode_node_name);
+
+       // Connect the complex operation to it's block
+       assert(pmap_contains(dump_info->node_name_map, dump_info->complex_operation_block) && "Complex operation's block predecessor must have already been dumped in the positive pattern!");
+       fprintf(fp, "%s%s -pos0_%d:df-> %s;\n", indent, VECTOR_OP_NAME, edge_counter++, pmap_get(dump_info->node_name_map, dump_info->complex_operation_block));
+
+       if(dump_info->has_result)
+       {
+               // Dump the res proj node projecting the complete vector out of the complex operation
+               fprintf(fp, "%s%s : Proj;\n", indent, VECTOR_OP_PROJDATA_NAME);
+               mode_node_name = dump_grgen_mode_node(mode_LLu, dump_info, fp);
+               fprintf(fp, "%s%s -:has_mode-> %s;\n", indent, VECTOR_OP_PROJDATA_NAME, mode_node_name);
+               fprintf(fp, "%s%s -pos0_%d:df-> %s;\n", indent, VECTOR_OP_PROJDATA_NAME, edge_counter++,  pmap_get(dump_info->node_name_map, dump_info->complex_operation_block));
+               fprintf(fp, "%s%s -pos1_%d:df-> %s;\n", indent, VECTOR_OP_PROJDATA_NAME, edge_counter++, VECTOR_OP_NAME);
+               sprintf(eval, "%s.proj = %d;", VECTOR_OP_PROJDATA_NAME, 0);
+               add_eval(dump_info, eval);
+       }
+
+
+       // Connect the complex operation to it's arguments
+       // Caution: The argument-nodes must have not been retyped!
+       i = 0;
+       max_argument = -1000;
+       pmap_foreach(dump_info->argument_nodes, entry)
+       {
+               ir_node *n = (ir_node *) entry->key;
+               ir_node *argument;
+               argument_descr_t *argument_descr = entry -> value;
+               int arg_nr = argument_descr->arg_nr;
+
+               if(arg_nr < 0)
+                       continue;
+               assert(pmap_contains(dump_info->node_name_map, n) && "The pointer base node must have already been dumped in the positive pattern!");
+
+               if(argument_descr->argument_location == ARGUMENT_SIMD_REGISTER)
+                       argument = n;
+               else
+                       argument = argument_descr->vec_op_input;
+
+               fprintf(fp, "%s%s -pos%d_%d:df-> %s;\n", indent, VECTOR_OP_NAME, arg_nr + 1, edge_counter++, pmap_get(dump_info->node_name_map, argument));
+               if(max_argument < arg_nr)
+                       max_argument = arg_nr;
+       }
+
+       // Do preparations to connect the memory edge to the complex operation
+       if(uses_memory)
+       {
+               // Dump a dummy in-edge used to connect the memory in manually later
+               fprintf(fp, "%s%s -pos%d_%d:df-> Bad%d : Bad;\n", indent, VECTOR_OP_NAME, max_argument + 2, edge_counter++, node_counter);
+
+               // Generate ProjM node to connect the rest of the replace pattern with
+               fprintf(fp, "%s%s : Proj;\n", indent, VECTOR_OP_PROJM_NAME);
+               fprintf(fp, "%s%s -:has_mode-> mode_M_node;\n", indent, VECTOR_OP_PROJM_NAME);
+               fprintf(fp, "%s%s -pos1_%d:df-> %s;\n", indent, VECTOR_OP_PROJM_NAME, edge_counter++, VECTOR_OP_NAME);
+               fprintf(fp, "%s%s -pos0_%d:df-> %s;\n", indent, VECTOR_OP_PROJM_NAME, edge_counter++, pmap_get(dump_info->node_name_map, dump_info->complex_operation_block));
+
+               // Add eval to set the proj nr
+               sprintf(eval, "%s.proj = %d;", VECTOR_OP_PROJM_NAME, (dump_info->has_result) ? 1 : 0);
+               add_eval(dump_info, eval);
+       }
+
+       i = 0;
+       pmap_foreach(dump_info->destroyed_regs, entry)
+       {
+               //ir_node *end_node = get_irg_end(dump_info->irg);
+               //char *end_name = pmap_get(dump_info->node_name_map, end_node);
+               char proj_name[255], keep_name[255];
+
+//             assert(end_name && "End node has to be already dumped in positive pattern!");
+
+               sprintf(proj_name, "Proj%d", node_counter++);
+               sprintf(keep_name, "IR_Keep%d", i);
+               fprintf(fp, "%s%s : Proj;\n", indent, proj_name);
+               fprintf(fp, "%s%s -:has_mode-> mode_LLu_node;\n", indent, proj_name);
+               fprintf(fp, "%s%s -pos0_%d:df-> %s;\n", indent, proj_name, edge_counter++, pmap_get(dump_info->node_name_map, dump_info->complex_operation_block));
+               fprintf(fp, "%s%s -pos1_%d:df-> %s;\n", indent, proj_name, edge_counter++, VECTOR_OP_NAME);
+               fprintf(fp, "%s%s : IR_Keep;\n", indent, keep_name);
+               fprintf(fp, "%s%s -pos%d_%d:df-> %s;\n", indent, keep_name, i + 1, edge_counter++, proj_name);
+               fprintf(fp, "%s%s -pos0_%d:df-> %s;\n", indent, keep_name, edge_counter++, pmap_get(dump_info->node_name_map, dump_info->complex_operation_block));
+               //fprintf(fp, "%s%s -:df-> %s;\n", indent, end_name, keep_name);
+               sprintf(eval, "%s.proj = %d;", proj_name, (dump_info->has_result + uses_memory + i));
+               add_eval(dump_info, eval);
+               i++;
+       }
+}
+
+
+
+/************************************************************************
+ * Dumps a node in GrGen Format
+ ************************************************************************/
+
+static void dump_grgen_node(ir_node *n, dump_info_t *dump_info, FILE *fp)
+{
+       char *node_name;
+
+       // Already dumped the node? Then do nothing
+       if(pmap_contains(dump_info -> node_name_map, n))
+               return;
+
+       // Else generate new node name and dump the node
+
+       node_name = obstack_alloc(&(dump_info -> node_names), MAX_NODENAME_LEN);
+
+       if(!pmap_contains(dump_info->argument_nodes, n))
+       {
+               register_access_descr_t *register_access_descr = pmap_get(dump_info->register_access, n);
+
+               if(n == dump_info->complex_operation_block)
+                       sprintf(node_name, "%s", COMPLEX_OPERATION_BLOCK_NAME);
+               else if(register_access_descr != NULL && register_access_descr -> load_store == REGISTER_STORE) // Register STORE nodes get a special name to be fao
+                       sprintf(node_name, "%s%d_%s%d", VECTOR_RESULT_NAME, register_access_descr->array_index, get_op_name(get_irn_op(n)), get_irn_node_nr(n));
+               else
+                       sprintf(node_name, "%s%d", get_op_name(get_irn_op(n)), get_irn_node_nr(n));
+
+               if(get_irn_opcode(n) == iro_Bad)  // A bad node that comes out of specification is a generic IR_node
+                       fprintf(fp, "%s%s : %s;\n", indent, node_name, "IR_node");
+               else
+                       fprintf(fp, "%s%s : %s;\n", indent, node_name, get_op_name(get_irn_op(n)));
+       }
+       else
+       {
+               // Argument nodes get a special name, so that they can be found after
+               // matching to test if their position is legal
+               argument_descr_t *arg_descr = pmap_get(dump_info->argument_nodes, n);
+               if(arg_descr->arg_nr != -1)
+                       sprintf(node_name, "Arg_%d", arg_descr->arg_nr);
+               else
+                       sprintf(node_name, "Result");  /// ???? What did I do here?
+               fprintf(fp, "%s%s : %s;\n", indent, node_name, VECTOR_BASE_TYPE);
+
+       }
+
+       pmap_insert(dump_info -> node_name_map, n, node_name);
+       node_counter++;
+}
+
+
+
+/************************************************************************
+ * Dump grGen code for retyping a node to a new opCode.
+ * The mode stays the same.
+ * Changes also the already saved node_name in node_name_map
+ * Returns the node name generated for the retyped node.
+ ************************************************************************/
+
+static char *dump_grgen_retyped_node(ir_node *n, ir_op *new_op, dump_info_t *dump_info, FILE *fp)
+{
+       char *node_name;
+
+       // A retyped node should have already been dumped.
+       assert(pmap_contains(dump_info->node_name_map, n));
+
+       // Else generate new node name and dump the retyped node
+       node_name = obstack_alloc(&(dump_info -> node_names), MAX_NODENAME_LEN);
+       sprintf(node_name, "%s%d", get_op_name(new_op), node_counter);
+       fprintf(fp, "%s%s : %s<%s>;\n", indent, node_name, get_op_name(new_op), pmap_get(dump_info->node_name_map, n));
+       pmap_insert(dump_info -> node_name_map, n, node_name);
+
+       // Save the retyped op
+       pmap_insert(dump_info -> retyped_nodes, n, (void *) new_op);
+       node_counter++;
+
+       // Dump the block of the original node had one.
+       // dump_grgen_edge(n, -1, dump_info, fp);
+
+       return(node_name);
+}
+
+
+
+/*************************************************************************
+ * Dumps 'delete' statements for all incoming egdes that have been matched
+ * except for the bock edge and the mode edge
+ * This is useful for nodes that were retyped to VProj or Sync and
+ * needing new incoming edges now;
+ *************************************************************************/
+
+void dump_grgen_delete_incoming_edges(ir_node *n, dump_info_t *dump_info, FILE *fp)
+{
+       char **nodes_edge_names;
+       int  i, deleted = 0;
+
+       // Delete all incoming edges of the original node since a retyped node
+       // will get new in edges (except the block edge and mode egde)
+
+       if(get_irn_arity(n) > 0)
+       {
+               fprintf(fp, "%sdelete(", indent);
+               nodes_edge_names = pmap_get(dump_info->edge_name_map, n);
+               assert(nodes_edge_names != NULL);
+
+               for(i = get_irn_arity(n); i > 0; i--)
+                       if(nodes_edge_names[i] != NULL)
+                       {
+                               fprintf(fp, "%c%s", (deleted == 0) ? ' ' : ',', nodes_edge_names[i]);
+                               deleted = 1;
+                       }
+
+                       fprintf(fp, ");\n");
+       }
+}
+
+
+
+/************************************************************************
+ * Dumps
+ * - The Block node of a ir_node if it has not been dumped before
+ * - The edge to the block node if n is not an argument or Const
+ ************************************************************************/
+
+static void dump_grgen_block(ir_node *n, dump_info_t *dump_info, FILE *fp)
+{
+       ir_node *block;
+       return;
+
+       if(get_irn_opcode(n) == iro_Block)  // A block has no block predecessor
+               return;
+
+       if(get_irn_opcode(n) == iro_Const || pmap_contains(dump_info->argument_nodes, n))
+               return;
+
+       if(get_irn_opcode(n) == iro_VProj)
+               return;
+
+       block = get_nodes_block(n);
+       // Dump the block node if necessary
+       if(!pmap_contains(dump_info->node_name_map, block))
+       {
+               dump_grgen_node(block, dump_info, fp);
+               dump_grgen_mode(block, dump_info, fp, NULL);
+       }
+
+       // Dump the edge to the block node
+       dump_grgen_edge(n, -1, dump_info, fp);
+}
+
+
+
+/************************************************************************
+ * Dumps an edge in GrGen format
+ ************************************************************************/
+
+static void dump_grgen_edge(ir_node *n, int n_edge, dump_info_t *dump_info, FILE *fp)
+{
+       ir_node *to_node;
+       char *from_node_name, *to_node_name;
+       char **nodes_edge_names;
+
+       // Don't dump a block edge if n is a block or n is a const or n is an argument for the complex
+       // operation which can be in a random block in the host graph
+       if(!dump_info->dump_everything)
+               if(n_edge == -1 && n != dump_info->node_to_match_block && (is_Block(n) || (get_irn_opcode(n) == iro_VProj && dump_info->priority != PRIORITY_CLEANUP /* HACK!!! */ ) ||
+                        get_irn_opcode(n) == iro_Const || get_irn_opcode(n) == iro_Cmp ||
+                       (get_irn_opcode(n) == iro_Proj && get_irn_modecode(n) != irm_M) ||
+                       get_irn_opcode(n) == iro_MultipleAdd ||
+                       get_irn_opcode(n) == iro_Load ||
+                       get_irn_opcode(n) == iro_Proj ||
+                       get_irn_opcode(n) == iro_Conv ||
+                       get_irn_op(n) == op_IrNode ||
+                       pmap_contains(dump_info->argument_nodes, n)))
+                               return;
+
+
+       // Check if to_node has also to be dumped. If not, skip this edge
+       // We have to dump to_node here, because to_node has to be known by grgen before
+       // connecting an edge to it.
+       to_node =  get_irn_n(n, n_edge);
+       if(!pmap_contains(dump_info -> nodes_to_dump, to_node))
+               return;
+
+       if((nodes_edge_names = pmap_get(dump_info -> edge_name_map, n)) == NULL)
+       {
+               nodes_edge_names = (char **) obstack_alloc(&(dump_info->node_names), (get_irn_arity(n) + 1) * sizeof(char *));
+               memset(nodes_edge_names, 0, (get_irn_arity(n) + 1) * sizeof(char *));
+               pmap_insert(dump_info->edge_name_map, n, nodes_edge_names);
+       }
+
+
+       // Is the target node a node with memory mode?
+       if(dump_info->dump_everything || get_mode_modecode(get_irn_mode(to_node)) != irm_M)
+       {
+               // No, we can dump the edge since it's no memory edge:
+
+               // Dumps node only when it was not dumped before
+               // dump_grgen_node(to_node, node_name_map, node_names, mode_name_map, mode_names, fp);
+               // dump_grgen_node(to_node, dump_info, fp);
+
+               assert(pmap_contains(dump_info -> node_name_map, n));
+               assert(pmap_contains(dump_info -> node_name_map, to_node));
+               from_node_name = (char *) pmap_get(dump_info -> node_name_map, n);
+               to_node_name = (char *) pmap_get(dump_info -> node_name_map, to_node);
+
+               // Don't dump edge number for certain nodes that are commutative (like ADD operation)
+               if(!dump_info->dump_everything && (n_edge != -1 && (get_irn_opcode(n) == iro_Add ||
+                  get_irn_opcode(n) == iro_MultipleAdd ||
+                  get_irn_opcode(n) == iro_Mul) ||
+                  get_irn_opcode(n) == iro_Block ||
+                  get_irn_opcode(n) == iro_Phi))
+               {
+                               char edge_name[50], *edge_name_obst;
+
+                               sprintf(edge_name, "e%d", edge_counter++);
+                               edge_name_obst = obstack_alloc(&(dump_info->node_names), strlen(edge_name) + 1);
+                               strcpy(edge_name_obst, edge_name);
+                               nodes_edge_names[n_edge + 1] = edge_name_obst;
+
+                               fprintf(fp, "%s%s -%s:df-> %s;\n", indent, from_node_name, edge_name_obst, to_node_name);
+               }
+               else
+               {
+                               char edge_name[50], *edge_name_obst;
+
+                               sprintf(edge_name, "pos%d_%d", n_edge + 1, edge_counter++);
+                               edge_name_obst = obstack_alloc(&(dump_info->node_names), strlen(edge_name) + 1);
+                               strcpy(edge_name_obst, edge_name);
+                               nodes_edge_names[n_edge + 1] = edge_name_obst;
+
+                               fprintf(fp, "%s%s -%s:df-> %s;\n", indent, from_node_name, edge_name_obst, to_node_name);
+               }
+               /*
+               switch(get_irn_opcode(n))
+               {
+                       case iro_Add:
+                       case iro_MultipleAdd:
+                       case iro_Mul:
+
+                               break;
+                       default:
+                               fprintf(fp, "%s%s -pos%d_%d:df-> %s;\n", indent, from_node_name, n_edge + 1, edge_counter++, to_node_name);
+                               break;
+               }*/
+
+       }
+}
+
+
+
+/************************************************************************
+ * Dumps an FIRM Mode as GrGen Code
+ * If source_node_name == NULL, that name of n that was already
+ * generated is used.
+ * If source_node_name != NULL, this given source will be used
+ * (useful for retyped nodes)
+ ************************************************************************/
+
+static void dump_grgen_mode(ir_node *n, dump_info_t *dump_info, FILE *fp, ir_mode *alt_mode)
+{
+       char *node_name = (char *) pmap_get(dump_info -> node_name_map, n);
+       ir_mode *irn_mode = (alt_mode != NULL) ? alt_mode : get_irn_mode(n);
+       char edge_name[50];
+       char *mode_node_name;
+
+       if(pmap_contains(dump_info->argument_nodes, n))
+               irn_mode = mode_ANY;
+       mode_node_name = dump_grgen_mode_node(irn_mode, dump_info, fp);
+
+       //mode_code =  get_mode_modecode(irn_mode);
+       //mode_name =  get_mode_name(irn_mode);
+
+
+
+#if 0
+       // Check if the mode node has already been created
+       if(!pmap_contains(dump_info -> mode_name_map, (void *) mode_code))
+       {
+               // No, create a new mode-node
+               mode_node_name = obstack_alloc(&(dump_info -> mode_names), MAX_NODENAME_LEN);
+               sprintf(mode_node_name, "mode_%s_node", mode_name);
+               pmap_insert(dump_info -> mode_name_map, (int *) mode_code, mode_node_name);
+               // Dump the edge from the current node to it's mode node
+               fprintf(fp, "%s%s -:has_mode-> %s : Mode_%s;\n", indent, node_name, mode_node_name, mode_name);
+       }
+       else
+       {
+#endif
+               // Yes, use the given mode-node
+               //mode_node_name = pmap_get(dump_info -> mode_name_map, (void *) mode_code);
+               sprintf(edge_name, "m%d", edge_counter++);
+
+
+               if(pmap_get(dump_info->mode_edge_map, n) == NULL)
+               {
+                       char *edge_name_obst = obstack_alloc(&(dump_info->node_names), strlen(edge_name) + 1);
+                       strcpy(edge_name_obst, edge_name);
+                       pmap_insert(dump_info->mode_edge_map, n, edge_name_obst);
+               }
+
+           // Dump the edge from the current node to it's mode node
+               fprintf(fp, "%s%s -%s:has_mode-> %s;\n", indent, node_name, edge_name, mode_node_name);
+#if 0
+       }
+#endif
+}
+
+
+
+/************************************************************************
+ * Dumps a node representing a node
+ ************************************************************************/
+
+char *dump_grgen_mode_node(ir_mode *irn_mode, dump_info_t *dump_info, FILE *fp)
+{
+       modecode mode_code = get_mode_modecode(irn_mode);
+       const char *mode_name =  get_mode_name(irn_mode);
+       char *mode_node_name;
+
+       if(!pmap_contains(dump_info -> mode_name_map, (void *) mode_code))
+       {
+               // No, create a new mode-node
+               mode_node_name = obstack_alloc(&(dump_info -> mode_names), MAX_NODENAME_LEN);
+               sprintf(mode_node_name, "mode_%s_node", mode_name);
+               pmap_insert(dump_info -> mode_name_map, (void *) mode_code, mode_node_name);
+               fprintf(fp, "%s%s : Mode_%s;\n", indent, mode_node_name, mode_name);
+               return(mode_node_name);
+       }
+       else
+       {
+               return((char *) pmap_get(dump_info -> mode_name_map, (void *) mode_code));
+       }
+
+}
+
+
+
+/************************************************************************
+ * Dumps the condition for the given node, depending on the node's
+ * attributes and the node's opcode
+ ************************************************************************/
+
+static void dump_grgen_condition(ir_node *n, dump_info_t *dump_info, FILE *fp)
+{
+       char *node_name;
+       ir_opcode code = get_irn_opcode(n);
+
+       if(code == iro_MultipleAdd)
+       {
+               node_name = pmap_get(dump_info->node_name_map, n);
+               fprintf(fp, "%s%s.arity == %d;\n", indent, node_name, get_irn_arity(n));
+               return;
+       }
+
+       if(code == iro_Const)
+       {
+               node_name = pmap_get(dump_info->node_name_map, n);
+               fprintf(fp, "%s%s.value == \"%d\";\n", indent, node_name, get_tarval_long(get_Const_tarval(n)));
+               return;
+       }
+
+       if(code == iro_VProj)
+       {
+               node_name = pmap_get(dump_info->node_name_map, n);
+               fprintf(fp, "%s%s.proj == %d;\n", indent, node_name, get_VProj_proj(n));
+               return;
+       }
+
+       if(code == iro_Proj)
+       {
+               if(!pmap_contains(dump_info->argument_nodes, n))
+               {
+                       node_name = pmap_get(dump_info->node_name_map, n);
+                       fprintf(fp, "%s%s.proj == %d;\n", indent, node_name, get_Proj_proj(n));
+               }
+               return;
+       }
+
+
+       if(code == iro_Phi)
+       {
+               ir_node *phi_block = get_nodes_block(n);
+               char **edge_names_phi, **edge_names_block;
+               int i;
+
+               assert((get_irn_arity(n) == get_irn_arity(phi_block)) && "Phi has other arity than it's block! Pattern seems to be broken.");
+
+               // Load the edge names that have been saved
+               edge_names_phi = pmap_get(dump_info->edge_name_map, n);
+               edge_names_block = pmap_get(dump_info->edge_name_map, phi_block);
+               assert(edge_names_phi && edge_names_block && "Some edge names have not been dumped!");
+
+               // Correlate the matched phi edges with the matched block edges
+               // Caution: Position 0 in the edge_names array is the block edge, so start at 1
+               for(i = 1; i < get_irn_arity(n) + 1; i++)
+               {
+                               assert(edge_names_phi[i] != NULL && edge_names_block[i] != NULL && "Some edges have not been dumped!");
+
+                               fprintf(fp, "%s%s.pos == %s.pos;\n", indent, edge_names_phi[i], edge_names_block[i]);
+               }
+               return;
+       }
+
+       assert(0 && "Nodes attributes not supported");
+}
+
+
+
+
+/************************************************************************
+ * Dump grGen code for retyping a special node
+ ************************************************************************/
+
+static void dump_retyping_to_vproj(ir_node *n, ir_node *complex_operation, dump_info_t *dump_info, char *vector_op_node_name, FILE *fp)
+{
+       // Dump the grGen code for retyping
+       register_access_descr_t *register_access_descr;
+       char *node_name;
+
+       /*char *node_name = obstack_alloc(&(dump_info->node_names), MAX_NODENAME_LEN);
+
+       // A node that should be retyped must be already there in the pattern part.
+       assert(pmap_contains(dump_info->node_name_map, n));
+       // Generate a node name for that VProj
+       sprintf(node_name, "VProj%d", node_counter);
+       fprintf(fp, "%s%s : VProj<%s>;\n", indent, node_name, pmap_get(dump_info->node_name_map, n));
+       dump_grgen_mode(n, dump_info, fp, node_name); */
+
+       node_name = dump_grgen_retyped_node(n, op_VProj, dump_info, fp);
+       dump_grgen_delete_incoming_edges(n, dump_info, fp);
+
+       // Dump the edge to the complex operation
+       fprintf(fp, "%s%s -pos1_%d:df-> %s;\n", indent, node_name, edge_counter++, vector_op_node_name);
+       node_counter++;
+
+       // Save generated VProj Node name for later usage
+       register_access_descr = pmap_get(dump_info->register_access, n);
+       register_access_descr->replace_node_name = node_name;
+}
+
+
+
+/************************************************************************
+ * Dump grGen code for retyping a special node
+ ************************************************************************/
+
+static void dump_retyping_to_proj(ir_node *n, ir_node *complex_operation, dump_info_t *dump_info, char *vector_op_node_name, FILE *fp)
+{
+       // Dump the grGen code for retyping
+       register_access_descr_t *register_access_descr;
+       char *node_name;
+
+
+       node_name = dump_grgen_retyped_node(n, op_Proj, dump_info, fp);
+       dump_grgen_delete_incoming_edges(n, dump_info, fp); // Will get a new edge to the complex op
+       dump_grgen_mode(n, dump_info, fp, NULL);
+
+       // Dump the edge to the complex operation
+       fprintf(fp, "%s%s -pos1_%d:df-> %s;\n", indent, node_name, edge_counter++, vector_op_node_name);
+       node_counter++;
+
+       // Save generated VProj Node name for later usage
+       register_access_descr = pmap_get(dump_info->register_access, n);
+       register_access_descr->replace_node_name = node_name;
+}
+
+
+
+/************************************************************************
+ * Dump grGen Code to add the VProj Nr to VProj nodes after replacement
+ ************************************************************************/
+
+static void dump_vproj_nr(dump_info_t *dump_info, FILE *fp)
+{
+       pmap_entry *entry;
+
+       pmap_foreach(dump_info -> register_access, entry)
+       {
+               ir_node *n = (ir_node *) entry->key;
+               register_access_descr_t *register_access_descr = entry->value;
+
+               // Only VProjs that represent a store have to be changed
+               if(register_access_descr->load_store == REGISTER_STORE)
+                       fprintf(fp, "%s%s.proj = %d;\n", indent, pmap_get(dump_info->node_name_map, n) /*register_access_descr->replace_node_name*/, register_access_descr->array_index);
+       }
+}
+
+
+/************************************************************************
+ * Sets current indent
+ ************************************************************************/
+
+void set_indent(int i)
+{
+       int j;
+
+       // Generate a string containing i blank characters
+       if(i < MAX_INDENT - 1)
+       {
+               for(j = 0; j < i; j++)
+                       indent[j] = ' ';
+               indent[j] = 0x0;
+               current_indent = i;
+       }
+}
+
+
+
+/************************************************************************
+ * Gets current indent value
+ ************************************************************************/
+
+int  get_indent(void)
+{
+       return(current_indent);
+}
+
+void dump_complex_operation_block_match(dump_info_t *dump_info, FILE *fp)
+{
+       fprintf(fp, "%s%s -:df-> %s;\n", indent, pmap_get(dump_info->node_name_map, dump_info->node_to_match_block), pmap_get(dump_info->node_name_map, dump_info->complex_operation_block));
+}
+
+
+/************************************************************************
+ * Dumps some evals which are mandatory
+ ************************************************************************/
+
+void dump_mandatory_evals(dump_info_t *dump_info, int uses_memory, FILE *fp)
+{
+       pmap_entry *entry;
+
+       pmap_foreach(dump_info->eval_statements, entry)
+       {
+               char *statement = (char *) entry->key;
+               fprintf(fp, "%s%s\n", indent, statement);
+       }
+}
+
+
+/************************************************************************
+ * Adds an eval to the list that has to be dumped at the end
+ ************************************************************************/
+
+void add_eval(dump_info_t *dump_info, char *eval)
+{
+       char *eval_obst = obstack_alloc(&(dump_info->node_names), strlen(eval) + 5);
+
+       strcpy(eval_obst, eval);
+       pmap_insert(dump_info->eval_statements, eval_obst, NULL);
+}
+
+
+
+/*************************************************************************
+ * Changes the mode of an already dumped node. Deletes the old mode edge
+ * and inserts a new one. To be used e.g. in the replacement graph.
+ *************************************************************************/
+
+void change_mode(ir_node *n, ir_mode *m, dump_info_t *dump_info, FILE *fp)
+{
+       char *mode_edge_name = pmap_get(dump_info->mode_edge_map, n);
+
+       if(mode_edge_name != NULL)
+       {
+               fprintf(fp, "%sdelete(%s);\n", indent, mode_edge_name);
+               pmap_insert(dump_info->mode_edge_map, n, NULL);
+               dump_grgen_mode(n, dump_info, fp, m);
+       }
+}
+
+
+/************************************************************************
+ * Sets up "fake" graph analysis information to just dump all nodes of
+ * an ir graph. Used for the AGTIVE workshop.
+ * Parameters: irg:    The irg to dump
+ *
+ *
+ ************************************************************************/
+
+void dump_irgraph_complete_grgen(ir_graph *irg, char *filename, int append)
+{
+       graph_ana_info_t graph_ana_info;
+       struct obstack obst;
+       grgen_dumper_env_t *gd_env;
+
+       obstack_init(&obst);
+
+       graph_ana_info.irg = irg;
+       graph_ana_info.nodes_to_dump = pmap_create();
+       graph_ana_info.register_access = pmap_create(); // Those pmaps are not filled here, but needed by the dumper
+       graph_ana_info.memory_access = pmap_create();
+       graph_ana_info.argument_nodes = pmap_create();
+       graph_ana_info.destroyed_regs = pmap_create();
+       graph_ana_info.obst = &obst;
+       graph_ana_info.num_simd_arguments = 0;
+       graph_ana_info.complex_operation_block = NULL;
+       graph_ana_info.node_to_match_block = NULL;
+       graph_ana_info.emit_statement = NULL;
+       graph_ana_info.has_result = 0;
+       graph_ana_info.variant_nr = 0;
+       graph_ana_info.priority = 0;
+       graph_ana_info.dump_everything = 1;
+
+       gd_env = init_grgen_dumper(filename, append);
+       irg_walk_graph(graph_ana_info.irg, collect_nodes, NULL, &graph_ana_info);
+       dump_irgraph_grgen(gd_env, &graph_ana_info);
+       deinit_grgen_dumper(gd_env);
+
+       pmap_destroy(graph_ana_info.nodes_to_dump);
+       pmap_destroy(graph_ana_info.destroyed_regs);
+       pmap_destroy(graph_ana_info.register_access);
+       pmap_destroy(graph_ana_info.memory_access);
+       pmap_destroy(graph_ana_info.argument_nodes);
+       obstack_free(&obst, NULL);
+       obstack_finish(&obst);
+}
+
+
+
+/************************************************************************
+ * Collects all nodes of a ir graph, so that the ir graph can be
+ * dumped completely
+ ************************************************************************/
+
+
+static void collect_nodes(ir_node *n, void * env)
+{
+       graph_ana_info_t *graph_ana_info = (graph_ana_info_t *) env;
+
+       pmap_insert(graph_ana_info->nodes_to_dump, n, NULL);
+}

diff --git a/ir/be/grgen/simd/grgen_dumper.h b/ir/be/grgen/simd/grgen_dumper.h
new file mode 100644 (file)
index 0000000..0ba73ec
--- /dev/null
+++ b/ir/be/grgen/simd/grgen_dumper.h
@@ -0,0 +1,27 @@
+/*************************************************************************
+* Program:  grgen_dumper.c
+* Function: Dumps parts of a firm graph (those which have to be extracted
+*                       as search and replace patterns) as a grgen rule.
+* Author:   Andreas Schoesser
+* Date:     2006-12-07
+*************************************************************************/
+
+#ifndef GRGEN_DUMPER_H
+#define GRGEN_DUMPER_H
+
+#include "create_pattern_t.h"
+
+
+typedef struct                 // Holds information needed througout the usage of a grgen dumper instance
+{
+       FILE *output_file;      // The file the grgen rules will be dumped to
+} grgen_dumper_env_t;
+
+
+
+grgen_dumper_env_t     *init_grgen_dumper(char *file, int append);
+int                                    dump_irgraph_grgen(grgen_dumper_env_t *grgen_dumper_env, graph_ana_info_t *walker_info);
+void                           deinit_grgen_dumper(grgen_dumper_env_t *grgen_dumper_env);
+void                           dump_irgraph_complete_grgen(ir_graph *irg, char *filename, int append);
+
+#endif

diff --git a/ir/be/grgen/simd/grgen_dumper__t.h b/ir/be/grgen/simd/grgen_dumper__t.h
new file mode 100644 (file)
index 0000000..3237da7
--- /dev/null
+++ b/ir/be/grgen/simd/grgen_dumper__t.h
@@ -0,0 +1,64 @@
+/*************************************************************************
+* Program:  grgen_dumper_t.h
+* Function: Dumps parts of a firm graph (those which have to be extracted
+*                       as search and replace patterns) as a grgen rule.
+* Author:   Andreas Schoesser
+* Date:     2007-01-11
+*************************************************************************/
+
+#ifndef GRGEN_DUMPER_H_T
+#define GRGEN_DUMPER_H_T
+
+#include "grgen_dumper.h"
+
+#define MAX_NODENAME_LEN 40
+
+typedef struct
+{
+       ir_graph *irg;
+       struct pmap *mode_edge_map;
+       struct pmap *edge_name_map;
+       struct pmap *node_name_map;  // Contains the mapping firm node -> node name
+       struct obstack node_names;   // Contains the node name data
+       struct pmap *mode_name_map;  // Contains the mapping firm mode -> mode node name
+       struct obstack mode_names;   // Contains the "mode node name" data
+       struct pmap *register_access;  // Contains all nodes that are register access and their vector component
+       struct pmap *memory_access;    // Contains all nodes that are memory access and their vector component
+       struct pmap *nodes_to_dump;         // Contains firm nodes, that have to be dumped
+       struct pmap *argument_nodes;    // Contains "pointer root nodes" (usually ProjP), which have to be transformed to a generic firm node mode P
+       struct pmap *retyped_nodes;         // Contains all nodes that were retyped in the replacement step and therefore no edges have to be dumped.
+                                                                               // (Retyped nodes get completely new edges in our case)
+       struct pmap *dump_condition;        // Contains all nodes for which a conditions has to be dumped afterwards.
+       struct pmap *eval_statements;       // Contains strings of eval statements dropped during replacement dumping and to be dumped at the end
+       struct pmap *destroyed_regs;
+       ir_node     *complex_operation_block, *node_to_match_block;
+       char        *node_name;
+       int         has_result;
+       int                     priority;
+       int                     dump_everything;        // Used to dump whole FIRM graphs with memory egdes ....
+} dump_info_t;
+
+static int dump_pattern(dump_info_t *dump_info, FILE *fp);
+static void dump_replacement(dump_info_t *dump_info, int uses_memory, FILE *fp);
+void dump_grgen_node(ir_node *n, dump_info_t *dump_info, FILE *fp);
+static char *dump_grgen_retyped_node(ir_node *n, ir_op *new_op, dump_info_t *dump_info, FILE *fp);
+static void dump_grgen_block(ir_node *n, dump_info_t *dump_info, FILE *fp);
+void dump_grgen_edge(ir_node *n, int n_edge, dump_info_t *dump_info, FILE *fp);
+static void dump_grgen_mode(ir_node *n, dump_info_t *dump_info, FILE *fp, ir_mode *alt_mode);
+char *dump_grgen_mode_node(ir_mode *irn_mode, dump_info_t *dump_info, FILE *fp);
+void dump_grgen_condition(ir_node *n, dump_info_t *dump_info, FILE *fp);
+static void dump_retyping_to_vproj(ir_node *n, ir_node *complex_operation, dump_info_t *dump_info, char *vector_op_node_name, FILE *fp);
+static void dump_retyping_to_proj(ir_node *n, ir_node *complex_operation, dump_info_t *dump_info, char *vector_op_node_name, FILE *fp);
+static void dump_vproj_nr(dump_info_t *dump_info, FILE *fp);
+void dump_complex_operation_block_match(dump_info_t *dump_info, FILE *fp);
+void dump_complex_operation(dump_info_t *dump_info, FILE *fp, int uses_memory);
+void dump_mandatory_evals(dump_info_t *dump_info, int uses_memory, FILE *fp);
+void add_eval(dump_info_t *dump_info, char *eval);
+void change_mode(ir_node *n, ir_mode *m, dump_info_t *dump_info, FILE *fp);
+void dump_grgen_delete_incoming_edges(ir_node *n, dump_info_t *dump_info, FILE *fp);
+static void collect_nodes(ir_node *n, void * env);
+
+void set_indent(int i);
+int  get_indent(void);
+
+#endif

diff --git a/ir/be/grgen/simd/normalize.c b/ir/be/grgen/simd/normalize.c
new file mode 100644 (file)
index 0000000..eb5ce7c
--- /dev/null
+++ b/ir/be/grgen/simd/normalize.c
@@ -0,0 +1,273 @@
+/*******************************************************************************************
+* Program:  normalize.c
+* Function: Part of the simd optimization. Provides functions to normalize a FIRM
+*                      graph in order to increase the number of patterns matched.
+* Author:   Andreas Schoesser
+* Date:     08.03.2007
+*******************************************************************************************/
+
+#include <malloc.h>
+#include <assert.h>
+
+#include "simd_presets.h"
+
+#include "pmap.h"
+#include "irgwalk.h"
+#include "ircons.h"
+#include "tv.h"
+#include "irgmod.h"
+#include "irnode.h"
+
+#include "normalize_t.h"
+#include "firm_node_ext.h"
+
+
+
+/************************************************************************
+ * Starts normalization of address calculations for Add and Store
+ * nodes. Folds Add-chains to one big MultipeAdd node.
+ ************************************************************************/
+
+struct pmap *normalize_address_calculation(ir_graph *irg, int decomposition_possible)
+{
+       normalize_info_t norm_info;
+
+       norm_info.irg = irg;
+       norm_info.replaced_ptrs = (decomposition_possible)      ? pmap_create() : NULL;
+
+       irg_walk_graph(irg, ac_walk_pre, NULL, &norm_info);
+
+       return(norm_info.replaced_ptrs);
+}
+
+
+
+/************************************************************************
+ * Called for each ir_node, in which the main work for normalization
+ * is done.
+ ************************************************************************/
+
+static void ac_walk_pre(ir_node *n, void * env)
+{
+       ir_node *addr, *multAdd;
+       normalize_info_t *norm_info = (normalize_info_t *) env;
+       ir_graph *irg = norm_info->irg;
+       int i, exchanged = 0;
+
+       switch(get_irn_opcode(n))
+       {
+               case iro_Load: addr = get_Load_ptr(n); break;
+               case iro_Store: addr = get_Store_ptr(n); break;
+               case iro_Proj:  if(get_irn_opcode(get_irn_n(n, 0)) == iro_Cmp)
+                                                       enforce_cmp_gt(n);
+                                               return;
+               default: return;
+       }
+
+       if(get_irn_opcode(addr) == iro_Add)
+       {
+               // Convert a ADD-chain to a single MultipleAdd node.
+
+               ir_node *add = addr;
+               int arity = 0;
+               int max_ins = 30;
+               ir_node **ins = malloc(max_ins * sizeof(ir_node *));
+
+               if(add_add_preds(add, ins, &max_ins, &arity) == 0)
+               {
+                       // We found no constant, add 0x0
+                       ins[arity++] = new_Const(mode_Is, new_tarval_from_long(0, mode_Is));
+               }
+               multAdd = new_ir_node(NULL, irg, get_nodes_block(addr), op_MultipleAdd, get_irn_mode(addr), arity, ins);
+
+               switch(get_irn_opcode(n))
+               {
+                       case iro_Load: set_Load_ptr(n, multAdd); break;
+                       case iro_Store: set_Store_ptr(n, multAdd); break;
+                       default: return;
+               }
+
+               // exchange(add, multAdd); Exchange wouldn't work here since the original ADD node would be killed.
+               if(norm_info->replaced_ptrs != NULL)
+                       pmap_insert(norm_info->replaced_ptrs, multAdd, add);
+               free(ins);
+       }
+       else if(get_irn_opcode(addr) != iro_MultipleAdd)
+       {
+               // Insert a new MultipleAdd node.
+               ir_node **ins = alloca(2 * sizeof(ir_node *));
+
+               ins[0] = addr;
+               ins[1] = new_Const(mode_Is, new_tarval_from_long(0, mode_Is));
+               multAdd = new_ir_node(NULL, irg, get_nodes_block(n), op_MultipleAdd, get_irn_mode(addr), 2, ins);
+               //exchange(addr, multAdd);
+               if(norm_info->replaced_ptrs != NULL)
+                       pmap_insert(norm_info->replaced_ptrs, multAdd, addr);
+
+               switch(get_irn_opcode(n))
+               {
+                       case iro_Load: set_Load_ptr(n, multAdd); break;
+                       case iro_Store: set_Store_ptr(n, multAdd); break;
+                       default: return;
+               }
+       }
+
+       /* Order the MultAdd ins to be compared quickly later. Bubble Sort */
+       do
+       {
+               exchanged = 0;
+               for(i = 0; i < get_irn_arity(multAdd) - 1; i++)
+               {
+                       ir_node *n1 = get_irn_n(multAdd, i),
+                                       *n2 = get_irn_n(multAdd, i + 1);
+
+                       // Move the Constant to pos0
+                       if(is_Const(n2) && !is_Const(n1))
+                       {
+                               set_irn_n(multAdd, i, n2);
+                               set_irn_n(multAdd, i + 1, n1);
+                               exchanged = 1;
+                               continue;
+                       }
+
+                       // Otherwise order by pointer value
+                       if(n1 > n2 && !is_Const(n1))
+                       {
+                               set_irn_n(multAdd, i, n2);
+                               set_irn_n(multAdd, i + 1, n1);
+                               exchanged = 1;
+                       }
+               }
+       } while(exchanged);
+
+}
+
+
+
+/************************************************************************
+ * Recursive function. Collects all adds of an "add chain" and inserts
+ * all the predecessors of the add chain into one ins array
+ ************************************************************************/
+
+int add_add_preds(ir_node *add, ir_node **ins, int *max_len, int *num_preds)
+{
+       int i, found_constant = 0;
+
+       for(i = 0; i < 2; i++)
+       {
+               ir_node *pred = get_irn_n(add, i);
+               switch(get_irn_opcode(pred))
+               {
+                       case iro_Add:   found_constant |= add_add_preds(pred, ins, max_len, num_preds);
+                                                       break;
+                       case iro_Const: found_constant |= 1;
+                                                       /* Fall through */
+                       default:                assert(*num_preds < *max_len && "Reallocation of temp ins array not implemented yet!");
+                                                       ins[*num_preds] = pred;
+                                                       (*num_preds)++;
+               }
+       }
+
+       return(found_constant);
+}
+
+
+
+/*******************************************************
+ * Decompose the normalization, that is replace all
+ * introduced MultipleAdds by their original ADD-Chain.
+ *******************************************************/
+
+void decompose_normalization(struct pmap *replaced_ptrs)
+{
+       pmap_entry *entry;
+
+       pmap_foreach(replaced_ptrs, entry)
+       {
+               ir_node *multAdd = (ir_node *) entry->key;
+               ir_node *orgAddr = (ir_node *) entry->value;
+
+               //if(get_irn_n_edges(multAdd) > 0)
+/*             switch(get_irn_opcode(loadStore))
+               {
+                       case iro_Load: set_Load_ptr(loadStore, orgAddr); break;
+                       case iro_Store: set_Store_ptr(loadStore, orgAddr); break;
+                       default: break; //return; //assert(0 && "Wrong opcode!");
+               }*/
+               exchange(multAdd, orgAddr);
+//             edges_node_deleted(multAdd, get_irn_irg(multAdd));
+       }
+
+       pmap_destroy(replaced_ptrs);
+}
+
+
+/************************************************************************
+ * Returns the original address that was replaced by a multiple add
+ ************************************************************************/
+
+ir_node *get_org_addr(ir_node *madd, struct pmap *replaced_ptrs)
+{
+       assert(get_irn_opcode(madd) == iro_MultipleAdd);
+       return(pmap_get(replaced_ptrs, madd));
+}
+
+
+
+/************************************************************************
+ * Enforces all compares lt to be gt
+ ************************************************************************/
+
+void enforce_cmp_gt(ir_node *proj)
+{
+       if(get_Proj_proj(proj) == pn_Cmp_Lt)
+       {
+               pn_Cmp new_pnc = get_inversed_pnc(get_Proj_proj(proj));
+               ir_node *tmp, *cmp = get_irn_n(proj, 0);
+
+               tmp = get_Cmp_left(cmp);
+               set_Cmp_left(cmp, get_Cmp_right(cmp));
+               set_Cmp_right(cmp, tmp);
+               set_Proj_proj(proj, new_pnc);
+       }
+}
+
+
+/************************************************************************/
+/*                                                                      */
+/************************************************************************/
+#if 0
+void normalize_direct_jump(ir_node *block)
+{
+       int block_arity = get_irn_arity(block);
+    int i, j;
+
+       if(block_arity > 1)
+       {
+               for(i = 0; i < block_arity; i++)
+               {
+                       ir_node *pred1 = get_irn_n(block, i);
+                       ir_node *cond;
+                       if(get_irn_opcode(pred1) == iro_Proj && get_irn_mode(pred1) == mode_X && get_Proj_proj(pred1) == 0 /* False */)
+                       {
+                               cond = get_irn_n(pred1, 0);
+                               assert(get_irn_op(cond) == iro_Cond);
+
+                               for(j = 0; i < block_arity; j++)
+                               {
+                                       ir_node *jmp = get_irn_n(block, j);
+
+                                       if(j == i)
+                                               continue;
+
+                                       if(get_irn_opcode(jmp) == iro_Jmp)
+                                       {
+                                               ir_node *jmp_block = get_nodes_block(jmp);
+                                               if(get_irn_arity(jmp_block) == 1 && get_irn_n(jmp_block)
+                                       }
+
+                               }
+               }
+       }
+}
+#endif

diff --git a/ir/be/grgen/simd/normalize.h b/ir/be/grgen/simd/normalize.h
new file mode 100644 (file)
index 0000000..f150e40
--- /dev/null
+++ b/ir/be/grgen/simd/normalize.h
@@ -0,0 +1,17 @@
+/*******************************************************************************************
+* Program:  normalize.h
+* Function: Part of the simd optimization. Provides functions to normalize a FIRM
+*                      graph in order to increase the number of patterns matched.
+* Author:   Andreas Schoesser
+* Date:     08.03.2007
+*******************************************************************************************/
+
+#ifndef __NORMALIZE_H__
+#define __NORMALIZE_H__
+
+/** */
+struct pmap *normalize_address_calculation(ir_graph *irg, int decomposition_possible);
+void decompose_normalization(struct pmap *replaced_ptrs);
+ir_node *get_org_addr(ir_node *madd, struct pmap *replaced_ptrs);
+
+#endif

diff --git a/ir/be/grgen/simd/normalize_t.h b/ir/be/grgen/simd/normalize_t.h
new file mode 100644 (file)
index 0000000..8be8333
--- /dev/null
+++ b/ir/be/grgen/simd/normalize_t.h
@@ -0,0 +1,24 @@
+/*******************************************************************************************
+ * Program:  normalize_t.h
+ * Function: Part of the simd optimization. Provides functions to normalize a FIRM
+ *                      graph in order to increase the number of patterns matched.
+ * Author:   Andreas Schoesser
+ * Date:     08.03.2007
+ *******************************************************************************************/
+
+#ifndef __NORMALIZE_T_H__
+#define __NORMALIZE_T_H__
+
+#include "irnode.h"
+
+static void ac_walk_pre(ir_node *n, void * env);
+int  add_add_preds(ir_node *add, ir_node **ins, int *max_len, int *num_preds);
+void enforce_cmp_gt(ir_node *proj);
+
+typedef struct
+{
+       ir_graph *irg;
+       struct pmap *replaced_ptrs;
+} normalize_info_t;
+
+#endif

diff --git a/ir/be/grgen/simd/presets.h b/ir/be/grgen/simd/presets.h
new file mode 100644 (file)
index 0000000..3205a0b
--- /dev/null
+++ b/ir/be/grgen/simd/presets.h
@@ -0,0 +1,13 @@
+/*************************************************************************
+* Program:  presets.h
+* Function: Preset values for simd optimizer
+* Author:   Andreas Schoesser
+* Date:     2006-12-20
+*************************************************************************/
+
+#ifndef _PRESETS_H_
+#define _PRESETS_H_
+
+#define MEMORY_ARRAY "memory_array"
+
+#endif

diff --git a/ir/be/grgen/simd/rule_info_dumper.c b/ir/be/grgen/simd/rule_info_dumper.c
new file mode 100644 (file)
index 0000000..d97209d
--- /dev/null
+++ b/ir/be/grgen/simd/rule_info_dumper.c
@@ -0,0 +1,97 @@
+/***********************************************************************
+ * Program:            rule_info_dumper.c
+ * Function:   Dumps C source code containig information about the
+ *                             generated GrGen rules into a .h file to be included
+ *                             when the compiler is recompiled to use the new GrGen
+ *                             rules.
+ * Depends on: Needs the analysis info generated by the pattern creator
+ * Author:             Andreas Schoesser
+ * Date:               2007-06-28
+ ************************************************************************/
+
+
+// ----------------------------- INCLUDES --------------------------------
+
+#include <malloc.h>
+
+#include "rule_info_dumper.h"
+#include "simd_presets.h"
+
+
+
+/************************************************************************
+ * Dumps the header of the "rulenames.c" file
+ * Rulenames.c contains information about
+ * - Which rules are defined,
+ * - Which name the assembly operation the complex operation gets
+ * - Which name the backend-firmnode the complex operation gets.
+ ************************************************************************/
+
+rule_info_env_t *init_rule_info_dumper(int max_num_rules)
+{
+       rule_info_env_t *rule_info_env = malloc(sizeof(rule_info_env_t));
+       FILE *fp = fopen(RULENAME_FILE, "wt");
+
+       fprintf(fp, "#ifdef INCLUDE_GENERATED_PATTERNS\n");
+       fprintf(fp, "typedef ir_node* (* ia32_construct_func_t) ();\n");
+       fprintf(fp, "ext_grs_action_t *rules[%d];\n", max_num_rules);
+       fprintf(fp, "char             *operation_names[%d];\n", max_num_rules);
+       fprintf(fp, "char             *firmnode_names[%d];\n", max_num_rules);
+       fprintf(fp, "int              priorities[%d][2];\n", max_num_rules);
+       fprintf(fp, "ia32_construct_func_t ia32_construct_funcs[%d];\n", max_num_rules);
+       fprintf(fp, "int              cost_savings[%d];\n", max_num_rules);
+       fprintf(fp, "\n");
+       fprintf(fp, "void fill_rulename_array()\n{\n");
+
+       rule_info_env->output_file = fp;
+       rule_info_env->num_rules = 0;
+       return(rule_info_env);
+}
+
+
+
+/************************************************************************
+ * Dumps the above information for each rule.
+ ************************************************************************/
+
+void dump_rule_info(rule_info_env_t *rule_info_env, graph_ana_info_t *graph_ana_info, int arity)
+{
+       FILE *fp = rule_info_env->output_file;
+       char name[255];
+       const char *firmnode_name;
+       int i = rule_info_env->num_rules;
+
+       get_rule_name(graph_ana_info, name);
+       firmnode_name = name;
+
+       fprintf(fp, "  {\n");
+       fprintf(fp, "    extern ext_grs_action_t *ext_grs_action_complex_instructions_%s;\n", name);
+       fprintf(fp, "    extern ia32_construct_func_t new_rd_ia32_%s;\n", firmnode_name);
+       fprintf(fp, "    rules[%d] = ext_grs_action_complex_instructions_%s;\n", i, name);
+       fprintf(fp, "    firmnode_names[%d] = \"%s\";\n", i, firmnode_name);
+       fprintf(fp, "    ia32_construct_funcs[%d] = (ia32_construct_func_t) &new_rd_ia32_%s;\n", i, firmnode_name);
+       fprintf(fp, "    priorities[%d][0] = %d;\n", i, i);
+       fprintf(fp, "    priorities[%d][1] = %d;\n", i, graph_ana_info->priority);
+       fprintf(fp, "    cost_savings[%d] = %d;\n", i, graph_ana_info->cost_savings);
+       fprintf(fp, "  }\n");
+
+       rule_info_env->num_rules++;
+}
+
+
+
+/************************************************************************
+ * Frees information used by the rule_info_dumper instance
+ ************************************************************************/
+
+void deinit_rule_info_dumper(rule_info_env_t *rule_info_env)
+{
+       FILE *fp = rule_info_env->output_file;
+
+       // Dump footer of rule pointers file
+       fprintf(fp, "}\n\n");
+       fprintf(fp, "#define NUM_RULES %d\n\n#endif\n", rule_info_env->num_rules);
+
+       fclose(rule_info_env->output_file);
+       free(rule_info_env);
+}

diff --git a/ir/be/grgen/simd/rule_info_dumper.h b/ir/be/grgen/simd/rule_info_dumper.h
new file mode 100644 (file)
index 0000000..79230d9
--- /dev/null
+++ b/ir/be/grgen/simd/rule_info_dumper.h
@@ -0,0 +1,31 @@
+/***********************************************************************
+* Program:             rule_info_dumper.c
+* Function:    Dumps C source code containig information about the
+*                              generated GrGen rules into a .h file to be included
+*                              when the compiler is recompiled to use the new GrGen
+*                              rules.
+* Author:              Andreas Schoesser
+* Date:                2007-06-28
+************************************************************************/
+
+#ifndef __RULE_INFO_DUMPER__
+#define __RULE_INFO_DUMPER__
+
+#include <stdio.h>
+#include "create_pattern_t.h"
+
+
+
+typedef struct                 // Holds information throughout the lifetime of a rule_info_dumper instance
+{
+       FILE *output_file;      // The file the rule information is written to
+       int num_rules;          // Holds the number of rules dumped so far
+} rule_info_env_t;
+
+
+rule_info_env_t *init_rule_info_dumper(int max_num_rules);
+void deinit_rule_info_dumper(rule_info_env_t *rule_info_env);
+void dump_rule_info(rule_info_env_t *rule_info_env, graph_ana_info_t *graph_ana_info, int arity);
+
+
+#endif

diff --git a/ir/be/grgen/simd/search_tree.c b/ir/be/grgen/simd/search_tree.c
new file mode 100644 (file)
index 0000000..8867409
--- /dev/null
+++ b/ir/be/grgen/simd/search_tree.c
@@ -0,0 +1,801 @@
+/************************************************************************
+ * Program:            Search_tree.c
+ * Project:            SIMD optimization
+ * Function:           Provides functions to build a search tree to
+ *                             select the patterns for rewrite
+ * Author:             Andreas Schoesser
+ * Date:                       2007-07-05
+ ************************************************************************/
+
+#include <stdio.h>
+#include <conio.h>
+
+#include "irgraph.h"
+#include "pmap.h"
+#include "irtools.h"
+
+#include "grs/match.h"
+
+#include "simd_presets.h"
+#include "search_tree_t.h"
+#include "firm_node_ext.h"
+
+
+struct pmap *applied_nodes;
+static int st_number = 0;
+
+
+/************************************************************************
+ * Builds a search tree
+ * TODO: Check if a match is valid, only then insert a search tree node,
+ *       but insert it into the ignore list
+ ************************************************************************/
+
+search_tree_node_t *build_search_tree(search_tree_env_t *search_tree_env, int prio_start)
+//void build_search_tree(search_tree_env_t *search_tree_env)//, int struct pmap *vec_operations, struct pmap *keep_nodes, int start, statistics_t *statistics, struct pmap *replaced_ptrs)
+{
+       plist_t **ignored_matches = alloca(search_tree_env->num_rules * sizeof(plist_t *));
+       search_tree_node_t *root;
+       int i;
+       char st_filename[255];
+
+       applied_nodes = pmap_create();
+       #if VERBOSE_REWRITE
+               printf("\n\nBuilding search tree for priority %d:\n\n", search_tree_env->priorities[1]);
+       #endif
+
+       // Create "list of matches to ignore" for each rule type
+       for(i = 0; i < search_tree_env->num_rules; i++)
+               ignored_matches[i] = plist_new();
+
+       root = rec_search_patterns(search_tree_env, search_tree_env->priorities[1], ignored_matches);
+
+       // Free "list of matches to ignore" for each rule type
+       for(i = 0; i < search_tree_env->num_rules; i++)
+       {
+               plist_clear(ignored_matches[i]);
+               plist_free(ignored_matches[i]);
+       }
+
+       #if VERBOSE_REWRITE
+               sprintf(st_filename, "%s-searchtree-%d.vcg", get_entity_name(get_irg_entity(search_tree_env->irg)), st_number++);
+               dump_search_tree(root, st_filename, "testtree", search_tree_env);
+       #endif
+
+       #if VERBOSE_REWRITE
+               printf("\n");
+       #endif
+
+       pmap_destroy(applied_nodes);
+
+       return(root);
+}
+
+
+
+/************************************************************************
+ * Frees the memory occupied by the search tree data structure
+ * Params: root: The root node of the search tree
+ ************************************************************************/
+
+void destroy_search_tree(search_tree_node_t *root)
+{
+       // Free memory preds
+       if(root->memory_preds != NULL)
+               pmap_destroy(root->memory_preds);
+
+       // Free the match and free subsequent search nodes recursively
+       if(root->match != NULL)
+       {
+               destroy_search_tree(root->with);
+               destroy_search_tree(root->without);
+               ext_grs_free_match(root->match);
+       }
+
+       // Free the current search tree node itself
+       free(root);
+}
+
+
+
+/************************************************************************
+ * Searches patterns recursively and tests what costs appear when
+ * the pattern we found would be applied or not.
+ ************************************************************************/
+
+static search_tree_node_t *rec_search_patterns(search_tree_env_t *st_env, int prio, plist_t **ignored_matches)
+{
+       int i, j, *prio_pos = st_env->priorities;
+
+       // Search all patterns in this priority
+       search_tree_node_t *st_node = malloc(sizeof(*st_node));
+
+       memset(st_node, 0, sizeof(*st_node));
+
+       for(; prio_pos[1] == prio; ) // TODO! Nach oben begrenzen!
+       {
+               int rule_nr = prio_pos[0];
+               ext_grs_match_t *match;
+
+               #if VERBOSE_REWRITE
+                       printf("\nSearching pattern %s (%d).", st_env->firmnode_names[rule_nr], rule_nr);
+               #endif
+
+               // Get ALL matches
+               match = ext_grs_match(st_env->irg, st_env->m_plans[rule_nr], ext_grs_ALL, ext_grs_REGARDLESS);
+               assert(match != NULL && "Panic! No memory for match!");
+               st_env->statistics->num_matches += ext_grs_get_n_matches(match);
+               st_env->statistics->num_matched_nodes += ext_grs_get_n_matches(match) * ext_grs_get_match_max_node_aiid(match);
+
+               // Now find the first one not to be ignored;
+               for(i = 0; i < ext_grs_get_n_matches(match); i++)
+               {
+                       if(!ignore_match(match, i, ignored_matches, rule_nr))
+                       {
+                               // Insert this match into ignore list
+                               plist_element_t *inserted_match = add_ignored_match(match, i, ignored_matches, rule_nr);
+                               plist_t *undo_vproj_info;
+                               int aa;
+
+                               #if VERBOSE_REWRITE
+                                       printf(" Found! %p", st_node);
+                               #endif
+
+                               // ** First look if we're allowed to apply the match **
+                               // Look if the arguments are in dominating blocks
+
+                               if((aa = analyze_arguments(st_env->rules[rule_nr], match, i, st_env->irg, NULL)) < 0)
+                               {
+
+                                       #if VERBOSE_REWRITE
+                                               if(aa == -1)
+                                                       printf(" Invalid arguments.");
+                                               else
+                                                       printf(" Argument dependency.");
+                                       #endif
+                                       return(st_node);
+                               }
+
+
+                               // Find the memory predecessors to be able to schedule the complex operation
+                               st_node->memory_preds = find_memory_preds(st_env->irg, ext_grs_get_match_node_map(match, i), st_env->rules[rule_nr]->max_node_aiid);
+
+                               // Do alias analysis and "LOAD usage" analysis" to see if pattern is really appliable.
+                               if(test_alias_relation(match->nodes[i], match->max_node_id, st_node->memory_preds, st_env->replaced_ptrs) != 0)
+                               {
+                                       #if VERBOSE_REWRITE
+                                               printf(" Rejected: Alias conflict!");
+                                       #endif
+                                       return(st_node);
+                               }
+
+
+                               // Arriving here means we're allowed to apply the match. Save information and look for
+                               // following matches with or without the current match.
+                               st_node->match = match;
+                               st_node->which_match = i;
+                               st_node->rule_nr = rule_nr;
+
+                               // call recursively
+                               st_node->without = rec_search_patterns(st_env, prio, ignored_matches);
+
+                               // Delete this pattern from the ignored ones
+                               delete_ignored_match(ignored_matches, inserted_match, rule_nr);
+
+
+                               // Insert vProj nodes
+                               undo_vproj_info = construct_vproj(st_env, st_node, rule_nr);
+
+                               // call again recursively
+                               #if VERBOSE_REWRITE
+                                       printf("\nApplying %p ", st_node);
+                               #endif
+                               insert_inner_nodes(st_env, st_node);
+                               st_node->with = rec_search_patterns(st_env, prio, ignored_matches);
+                               remove_inner_nodes(st_env, st_node);
+                               #if VERBOSE_REWRITE
+                                       printf("\nFinished Applying %p\n", st_node);
+                               #endif
+
+                               // Destroy VProj nodes
+                               deconstruct_vproj(undo_vproj_info);
+
+
+                               // Build the search tree node for this match
+
+                               st_node->this_matchs_costsavings = st_env->cost_savings[rule_nr] - ext_result_costs(st_node->match, st_node->which_match);
+                               st_node->cost_savings = MAX((st_node->without->cost_savings), (st_node->with->cost_savings + st_node->this_matchs_costsavings));
+
+
+                               return(st_node);
+                       }
+               }
+               prio_pos += 2;
+       }
+       return(st_node);
+}
+
+
+
+/*_                                _                   _
+ (_) __ _ _ __   ___  _ __ ___  __| |  _ __   ___   __| | ___  ___
+ | |/ _` | '_ \ / _ \| '__/ _ \/ _` | | '_ \ / _ \ / _` |/ _ \/ __|
+ | | (_| | | | | (_) | | |  __/ (_| | | | | | (_) | (_| |  __/\__ \
+ |_|\__, |_| |_|\___/|_|  \___|\__,_| |_| |_|\___/ \__,_|\___||___/
+       |___/                                                                                                           */
+
+
+/************************************************************************
+ * Adds a certain match to the list of ignored matches
+ * Prarms:     match:  The match object to be inserted
+ *                     which:  The match number inside the match object to be inserted
+ *                     ignored_matches: Array of list of matches to be ignored
+ *                     rule_nr:        The rule which found the match
+ * Returns: List element containing the ignored match
+ ************************************************************************/
+
+static plist_element_t *add_ignored_match(ext_grs_match_t *match, int which, plist_t **ignored_matches, int rule_nr)
+{
+       ignored_match_t *imatch = malloc(sizeof(*imatch));
+       //memset(imatch, 0, sizeof(*imatch));
+
+       imatch->nodes = generate_nodemap_hash(ext_grs_get_match_node_map(match, which), ext_grs_get_match_max_node_aiid(match));
+       // imatch->edges = ext_grs_get_match_edge_map(match, which);
+
+       plist_insert_back(ignored_matches[rule_nr], imatch);
+       return(plist_last(ignored_matches[rule_nr]));
+}
+
+
+
+/************************************************************************
+ * Removes a certain match to the list of ignored matches
+ * Params: ignored_matches: List of matches to be ignored
+ *                match_to_delete: List element of ignored_matches to be deleted
+ ************************************************************************/
+
+static void delete_ignored_match(plist_t **ignored_matches, plist_element_t *match_to_delete, int rule_nr)
+{
+       ignored_match_t *imatch = match_to_delete->data;
+       pmap_destroy(imatch->nodes);
+       free(imatch);
+       plist_erase(ignored_matches[rule_nr], match_to_delete);
+}
+
+
+
+/************************************************************************
+ * Test, if a certain match is in the ignore list
+ * Returns: 0 if the match is not in the list
+ *          1 if the match has to be ignored
+ * Prarms:     match:  The match object to be tested
+ *                     which:  The match number inside the match object to be tested
+ *                     ignored_matches: Array of list of matches to be ignored
+ *                     rule_nr:        The rule which found the match
+ ************************************************************************/
+
+static int ignore_match(ext_grs_match_t *match, int which, plist_t **ignored_matches, int rule_nr)
+{
+       int j;
+       plist_element_t *el;
+       pmap_entry *pen = NULL;
+       ir_node **node_map = ext_grs_get_match_node_map(match, which);
+       ir_edge_t **edge_map = ext_grs_get_match_edge_map(match, which);
+       int max_aiid = ext_grs_get_match_max_node_aiid(match);
+
+       // Iterate over all matches to be ignored of rule type "rule_nr"
+       foreach_plist(ignored_matches[rule_nr], el)
+       {
+               ignored_match_t *imatch = (ignored_match_t *) el->data;
+               int difference = 0;
+
+               for(j = 0; j <= max_aiid; j++)
+                       // if((pen = pmap_get(imatch->nodes, node_map[j])) == NULL) /// HAEEE? Why does this not work????
+                       if(!pmap_contains(imatch->nodes, node_map[j]))
+                       {
+                               difference = 1; // We have a difference. Proceed with next saved match
+                               break;
+                       }
+
+               if(difference == 0)
+               {
+                       #if VERBOSE_REWRITE
+                               printf(" Ignoring: Already matched in %p", pen);
+                       #endif
+                       return(1); // There is no difference beetween the two, that means we found 2 identical matches
+               }
+       }
+
+       // Now look if match's nodes don't collide with inner nodes of already applied matches
+       for(j = 0; j <= max_aiid; j++)
+               if((pen = pmap_get(applied_nodes, node_map[j])) != 0)
+               {
+                       #if VERBOSE_REWRITE
+                               printf(" Overlapping with %p", pen);
+                       #endif
+                       return(1);
+               }
+
+
+       return(0);
+}
+
+
+/************************************************************************
+ * Insert inner nodes of an applied pattern into a global pmap
+ ************************************************************************/
+
+void insert_inner_nodes(search_tree_env_t *st_env, search_tree_node_t *st_node)
+{
+       ir_node **nodes = ext_grs_get_match_node_map(st_node->match, st_node->which_match);
+       int max_id = ext_grs_get_match_max_node_aiid(st_node->match, st_node->which_match);
+       int i;
+       ext_grs_node_t **act_nodes = st_node->match->action->nodes;
+       int len = strlen(VECTOR_RESULT_NAME);
+
+       for(i = 0; i < max_id; i++)
+       {
+               // Ignore Agrument nodes of the pattern
+               if(act_nodes[i]->op == op_IrNode) // Generic argument nodes
+                       continue;
+               if(strncmp(act_nodes[i]->name, "Arg_", 4) == 0) // explicit argument nodes, that is Vector Base
+                       continue;
+               if(get_irn_opcode(nodes[i]) == iro_Const)
+                       continue;
+               if(get_irn_opcode(nodes[i]) == iro_VProj)
+                       continue;
+               if(get_irn_opcode(nodes[i]) == iro_Block)
+                       continue;
+               pmap_insert(applied_nodes, nodes[i], (void *) st_node); // Annotate which node produced that node
+       }
+}
+
+
+
+/************************************************************************
+ *
+ ************************************************************************/
+
+void remove_inner_nodes(search_tree_env_t *st_env, search_tree_node_t *st_node)
+{
+       ir_node **nodes = ext_grs_get_match_node_map(st_node->match, st_node->which_match);
+       int max_id = ext_grs_get_match_max_node_aiid(st_node->match, st_node->which_match);
+       int i;
+
+       for(i = 0; i < max_id; i++)
+               if(pmap_contains(applied_nodes, nodes[i]))
+                       pmap_insert(applied_nodes, nodes[i], 0); // Ugly, can't remove from pmap!
+}
+
+
+
+/* ___                     _    __     ______            _
+  |_ _|_ __  ___  ___ _ __| |_  \ \   / /  _ \ _ __ ___ (_)
+   | || '_ \/ __|/ _ \ '__| __|  \ \ / /| |_) | '__/ _ \| |
+   | || | | \__ \  __/ |  | |_    \ V / |  __/| | | (_) | |
+  |___|_| |_|___/\___|_|   \__|    \_/  |_|   |_|  \___// |
+                                                      |__/ */
+
+/************************************************************************
+ * Insert "artificial" VProj and Complex Instruction nodes
+ * Annotate at these nodes which match "created" them.
+ ************************************************************************/
+
+static plist_t *construct_vproj(search_tree_env_t *st_env, search_tree_node_t *st_node, int rule_nr)
+{
+       char node_name[50];
+       int result_nr = 0, result_aiid;
+       plist_t *undo_info = plist_new();
+       ext_grs_match_t *match = st_node->match;
+       int which =     st_node->which_match;
+
+       // Find out if the match has VProj results and how many
+       // This is done by looking for the node names Result_0_... - Result_n_...
+       // The right node names have to be created by the pattern creator before!
+
+       sprintf(node_name, "%s%d", VECTOR_RESULT_NAME, result_nr);
+       if((result_aiid = ext_grs_act_get_node_aiid_n(st_env->rules[rule_nr], node_name, strlen(node_name))) >= 0)
+       {                                                                                                                                               // Yes, it has vector results
+               ir_node **nodes = ext_grs_get_match_node_map(match, which);
+               ir_node *ins[1], *dataproj, *block, *complex;
+               pmap_entry *pen;
+
+               block = get_nodes_block(nodes[result_aiid]);
+
+               // Insert artificial complex instruction
+               ins[0] = NULL;
+               pmap_foreach(st_node->memory_preds, pen)
+               {
+                       ins[0] = get_irn_n(pen->key, 0); //(pen->key);
+                       pmap_break(st_node->memory_preds);
+               }
+               complex = new_ir_node(NULL, st_env->irg, block, op_FakeComplex, mode_T, (ins[0] == NULL) ? 0 : 1, &ins[0]);
+               ins[0] = complex;
+               dataproj = new_ir_node_with_update(NULL, st_env->irg, block, op_Proj, mode_LLu, 1, ins);
+               insert_which_match_vproj(st_env, dataproj, st_node->match, st_node->which_match, -1);
+               ins[0] = dataproj;
+
+               // Insert the VProjs, connect them with the complex instruction node
+               do
+               {
+                       ir_node *result_node = nodes[result_aiid];
+                       ir_node *new_vproj;
+                       ir_edge_t *res_succ, **outs;
+                       int n_edges, i = 0;
+                       undo_vproj_t *undo_vproj = malloc(sizeof(*undo_vproj));
+
+                       // Create a new VProj node
+                       new_vproj = new_ir_node_with_update(NULL, st_env->irg, get_nodes_block(result_node), op_VProj, get_irn_mode(result_node), 1, ins);
+                       set_VProj_proj(new_vproj, result_nr);
+
+                       // Save undo info for that VProj node
+                       undo_vproj -> vproj_node = new_vproj;
+                       undo_vproj -> org_result = result_node;
+                       plist_insert_back(undo_info, undo_vproj);
+
+                       // Save for each VProj, which match "created" them
+                       //pmap_insert(st_env->which_match_vproj, new_vproj, st_node);
+                       insert_which_match_vproj(st_env, new_vproj, st_node->match, st_node->which_match, result_aiid);
+
+                       // Now connect the result's successors to the Vproj, remember the old connections
+                       n_edges = get_irn_n_edges(result_node);
+                       NEW_ARR_A(ir_edge_t *, outs, n_edges);
+
+                       foreach_out_edge(result_node, res_succ)
+                       {
+                               assert(i < n_edges);
+                               outs[i++] = res_succ;
+                       }
+
+                       for(i = 0; i < n_edges; i++)
+                       {
+                               // Rewire
+                               set_irn_n(outs[i]->src, outs[i]->pos, new_vproj);
+                       }
+
+
+                       // Search the next node.
+                       sprintf(node_name, "%s%d", VECTOR_RESULT_NAME, ++result_nr);
+               } while((result_aiid = ext_grs_act_get_node_aiid_n(st_env->rules[rule_nr], node_name, strlen(node_name))) >= 0);
+       }
+
+       //dump_ir_block_graph(st_env->irg, "inserted_vproj");
+
+       return(undo_info);
+
+}
+
+
+
+/************************************************************************
+ * Connects the successors of the inserted VProjs with their original
+ * arguments again. Does NOT erase the VProj nodes from the graph,
+ * they are still needed.
+ * Frees the undo info
+ ************************************************************************/
+
+static void deconstruct_vproj(plist_t *undo_vproj_info)
+{
+       plist_element_t *el;
+
+       // Undo every VProj inserted
+       foreach_plist(undo_vproj_info, el)
+       {
+               undo_vproj_t *undo_vproj = el->data;
+               ir_edge_t **outs, *vproj_succ;
+               int i = 0, n_edges;
+
+               assert(get_irn_opcode(undo_vproj->vproj_node) == iro_VProj);
+
+               // Save all outs
+               n_edges = get_irn_n_edges(undo_vproj->vproj_node);
+               NEW_ARR_A(ir_edge_t *, outs, n_edges);
+               foreach_out_edge(undo_vproj->vproj_node, vproj_succ)
+               {
+                       assert(i < n_edges);
+                       outs[i++] = vproj_succ;
+               }
+
+               // Rewire
+               for(i = 0; i < n_edges; i++)
+                       set_irn_n(outs[i]->src, outs[i]->pos, undo_vproj->org_result);
+
+               // TODO!! Remove VProjs from matchers nodes list!
+
+               // Free undo info
+               free(undo_vproj);
+
+       }
+
+       plist_clear(undo_vproj_info);
+       plist_free(undo_vproj_info);
+}
+
+
+
+/************************************************************************
+ * Creates an entry in the which_match_vproj pmap to indicate
+ * which match created which vproj node and where to find the
+ * the REAL vproj node that was created by the replacement
+ ************************************************************************/
+
+static void insert_which_match_vproj(search_tree_env_t *st_env, ir_node *vproj, ext_grs_match_t *match, int which, int aiid)
+{
+       which_match_vproj_t *wmv = obstack_alloc(st_env->obst, sizeof(*wmv));
+
+       wmv->match = match;
+       wmv->which = which;
+       wmv->aiid  = aiid;
+
+       pmap_insert(st_env->which_match_vproj, vproj, wmv);
+}
+
+
+/*              _                                     _
+ _ __ ___ _ __ | | __ _  ___ ___ _ __ ___   ___ _ __ | |_
+| '__/ _ \ '_ \| |/ _` |/ __/ _ \ '_ ` _ \ / _ \ '_ \| __|
+| | |  __/ |_) | | (_| | (_|  __/ | | | | |  __/ | | | |_
+|_|  \___| .__/|_|\__,_|\___\___|_| |_| |_|\___|_| |_|\__|
+         |_|                                                  */
+
+/************************************************************************
+ * Walk over search tree
+ * Replace those patterns with the greates saving of costs
+ * Params: root: root of the search tree
+ ************************************************************************/
+
+void replace_search_tree(search_tree_node_t *root, replace_st_env_t *rep_env)
+{
+       char force_apply, suggestion;
+
+       if(root->match == NULL)
+               return;
+
+       #if VERBOSE_REWRITE
+       suggestion = ((root->without->cost_savings) > (root->with->cost_savings + root->this_matchs_costsavings)) ? 'n' : 'y';
+       printf("\nApply RULE %s? Suggested: %c (y/n): ", rep_env->firmnode_names[root->rule_nr], suggestion);
+               #if PROMPT_REWRITE
+                       force_apply = getch();
+               #endif
+       #endif
+
+
+       #if VERBOSE_REWRITE && PROMPT_REWRITE
+       if(force_apply == 'n' || force_apply == 'N')  // User driven
+       #else
+       if((root->without->cost_savings) >= (root->with->cost_savings + root->this_matchs_costsavings)) // Cost driven
+       #endif
+       {
+               #if VERBOSE_REWRITE
+                       printf("n");
+               #endif
+               // Go on with the "not replaced" edge
+               replace_search_tree(root->without, rep_env);
+       }
+       else
+       {
+               int which[1];
+               char match_postfix[100];
+
+               #if VERBOSE_REWRITE
+                       printf("y");
+               #endif
+
+               // Manipulate the match to use the VProjs of its predecessor
+               manipulate_match(rep_env, root->match, root->which_match);
+
+               // Rewrite the Match
+               which[0] = root->which_match;
+               ext_grs_finish_match(root->match, 1, &which[0]);
+
+               connect_complex_memory(rep_env->rules[root->rule_nr], root->match, root->which_match, root->memory_preds);
+               save_complex_operation(rep_env->rules[root->rule_nr], root->match, root->which_match, rep_env->vec_operations, root->rule_nr);
+               save_keep_nodes(rep_env->rules[root->rule_nr], root->match, root->which_match, rep_env->keep_nodes);
+               set_complex_operation_block(rep_env->irg, root->match, root->which_match);
+
+               //sprintf(match_postfix, "-REWRITTEN-%d-%d", i, j);
+               //dump_ir_block_graph(irg, match_postfix);
+               rep_env->statistics -> num_instructions_inserted++;
+               rep_env->statistics -> num_replaced_nodes += root->match->n_nodes;
+               rep_env->statistics -> rewritten_patterns[root->rule_nr]++;
+
+               // Go on with the "replaced" edge
+               replace_search_tree(root->with, rep_env);
+       }
+}
+
+
+
+/************************************************************************
+ * Manipulate Match object before replacement to not use the
+ * temporarily created VProj nodes but the VProj nodes created by
+ * the previous replacement.
+ ************************************************************************/
+
+static void manipulate_match(replace_st_env_t *rep_env, ext_grs_match_t *match, int which)
+{
+       /*      TODO:
+               * Find out which nodes and edges have to be manipulated
+                 - Iterate through matches array
+                 - Look if a  node is inside the which_match_vproj map
+                 - Retrieve the preceeding match object
+                 -
+       */
+
+       int max_aiid = ext_grs_get_match_max_node_aiid(match);
+       ir_node **node_map = ext_grs_get_match_node_map(match, which);
+       which_match_vproj_t *wmv;
+       int i;
+
+       // Manipulate nodes
+       for(i = 0; i < max_aiid; i++)
+       {
+               if((wmv = (which_match_vproj_t *) pmap_get(rep_env->which_match_vproj, node_map[i])) != NULL)
+               {
+                       // We found an entry that has to be rewired.
+                       if(wmv->aiid >= 0)
+                       {
+                               // It's a retyped result node. Follow "kept" array that points to the replace_node_map
+                               ir_node **repl_node_map = wmv->match->repl_nodes[wmv->which];
+                               node_map[i] = repl_node_map[wmv->match->action->pattern_node_kept[wmv->aiid]];
+                       }
+                       else
+                       {
+                               // It's the vector proj, which is not in the "kept" array since it was newly inserted.
+                               // Search for it by name in the replace_node_map
+                               int aiid = ext_grs_act_get_node_aiid(wmv->match->action, VECTOR_OP_PROJDATA_NAME);
+                               ir_node **repl_node_map = wmv->match->repl_nodes[wmv->which];
+                               assert(aiid >= 0 && "Vector_Op_ProjData not found!");
+                               node_map[i] = repl_node_map[aiid];
+                       }
+               }
+       }
+
+       // Manipulate edges! Maybe not even necessary! As well as Vprojs, we just need the
+       // Vector_op_ProjData node!
+}
+
+
+
+/************************************************************************
+* Find the block to place the complex operation in
+* We have to think here:
+* Maybe we should prefer the blocks of the memory nodes. If no memory
+* nodes there, the algorithm should be correct.
+************************************************************************/
+
+void set_complex_operation_block(ir_graph *irg, ext_grs_match_t *match, int which)
+{
+       ir_node **nodes = ext_grs_get_replace_node_map(match, which);
+       int max_id = match->action->max_repl_node_aiid;
+       int i, aiid;
+
+       ir_node *current_block = NULL;
+
+       assure_doms(irg);
+
+       for(i = 0; i <= max_id; i++)
+       {
+               if(nodes[i] != NULL)
+               {
+                       ir_opcode opc = get_irn_opcode(nodes[i]);
+                       if(opc != iro_Conv && match->action->replacement_nodes[i]->op != op_IrNode /* Its a generic Vector Base */ && opc != iro_VProj && opc != iro_MultipleAdd && opc != iro_Block && opc != iro_Const && strncmp(match->action->replacement_nodes[i]->name, "Arg_", 4) != 0)
+                       {
+                               if(current_block == NULL)
+                                       current_block = get_nodes_block(nodes[i]);
+                               else
+                               {
+                                       ir_node *this_block = get_nodes_block(nodes[i]);
+                                       if(this_block && this_block != current_block && block_dominates(this_block, current_block))
+                                               current_block = this_block;
+                               }
+                       }
+               }
+       }
+
+       // Set the Block for the complex operation and it's projs
+       assert(current_block != NULL);
+       set_nodes_block(nodes[ext_grs_act_get_node_aiid(match->action,  VECTOR_OP_PROJDATA_NAME)], current_block);
+       set_nodes_block(nodes[ext_grs_act_get_node_aiid(match->action,  VECTOR_OP_NAME)], current_block);
+       if((aiid = ext_grs_act_get_node_aiid(match->action,  VECTOR_OP_PROJM_NAME)) >= 0)
+               set_nodes_block(nodes[aiid], current_block);
+}
+
+
+
+
+/*                       _       _                       _
+ ___  ___  __ _ _ __ ___| |__   | |_ _ __ ___  ___    __| |_   _ _ __ ___  _ __   ___ _ __
+/ __|/ _ \/ _` | '__/ __| '_ \  | __| '__/ _ \/ _ \  / _` | | | | '_ ` _ \| '_ \ / _ \ '__|
+\__ \  __/ (_| | | | (__| | | | | |_| | |  __/  __/ | (_| | |_| | | | | | | |_) |  __/ |
+|___/\___|\__,_|_|  \___|_| |_|  \__|_|  \___|\___|  \__,_|\__,_|_| |_| |_| .__/ \___|_|
+                                                                                 |_|                  */
+
+/***********************************************************************
+ * Dumps search trees in VCG Format
+ ************************************************************************/
+
+int glob_node_nr = 0;
+void dump_search_tree(search_tree_node_t *root, char *file, char *graph_name, search_tree_env_t *st_env)
+{
+       FILE *fp = fopen(file, "wt");
+       assert(fp && "Could not open file to dump");
+
+       // Print vcg header
+       fprintf(fp,
+               "graph: { title: \"ir graph of %s\"\n"
+               "display_edge_labels: yes\n"
+               "layoutalgorithm: mindepth\n"
+               "manhattan_edges: yes\n"
+               "port_sharing: no\n"
+               //"orientation: %s\n"
+               "infoname 1: \"Test\"\n",
+               graph_name);//, label, orientation);
+       fprintf(fp, "\n");        /* a separator */
+
+       glob_node_nr = 0;
+       rec_dump_search_tree(root, fp, 0, st_env, 1);
+
+       // Dump Footer
+       fprintf(fp, "}\n");
+       fclose(fp);
+}
+
+
+
+/************************************************************************
+ * Called for each search tree node recursively and dumps its
+ * information
+ * Params: bestcost:   1 If we're on the path with the best costs
+ ************************************************************************/
+
+int rec_dump_search_tree(search_tree_node_t *node, FILE *fp, int this_node_nr, search_tree_env_t *st_env, int best_cost)
+{
+       int next_node_nr = this_node_nr;
+       ir_node **nodes;
+       char args[1000], arg_name[20], tmp[1000];
+       int i = 0, aiid, replace;
+       args[0] = 0;
+
+       if(node->match != NULL)
+       {
+               nodes = ext_grs_get_match_node_map(node->match, node->which_match);
+
+               do
+               {
+                       sprintf(arg_name, "Arg_%d", i);
+                       aiid = ext_grs_act_get_node_aiid(node->match->action, arg_name);
+                       if(aiid >= 0)
+                       {
+                               sprintf(tmp, "Arg_%d: %s %d ", i, get_irn_opname(nodes[aiid]), get_irn_node_nr(nodes[aiid]));
+                               strcat(args, tmp);
+                               strcat(args, "\n");
+                       }
+                       i++;
+               } while(aiid >= 0);
+               sprintf(tmp, "st_node: %p\n", node);
+               strcat(args, tmp);
+               sprintf(tmp, "CostSavings: %d\n", node->cost_savings);
+               strcat(args, tmp);
+               sprintf(tmp, "CostSavings this node %d\n", node->this_matchs_costsavings);
+               strcat(args, tmp);
+
+               replace = ((node->without->cost_savings) > (node->with->cost_savings + node->this_matchs_costsavings)) ? 0 : 1;
+
+               fprintf(fp, "node: { title: \"n%d\" label: \"%s\" color:%s info1: \"%s\" }\n", this_node_nr, st_env->rules[node->rule_nr]->name, (replace && best_cost) ? "red" : "white", args);
+
+               if(node->with->match != NULL)
+               {
+                       fprintf(fp, "edge: { sourcename: \"n%d\" targetname: \"n%d\" label: \"1\" color:%s}\n", this_node_nr, this_node_nr+1, (replace==1 && best_cost) ? "red" : "black");
+                       next_node_nr = rec_dump_search_tree(node->with, fp, this_node_nr + 1, st_env, (replace==1 && best_cost));
+               }
+
+               if(node->without->match != NULL)
+               {
+                       fprintf(fp, "edge: { sourcename: \"n%d\" targetname: \"n%d\" label: \"0\" color:%s}\n", this_node_nr, next_node_nr+1, (replace==0 && best_cost) ? "red" : "black");
+                       next_node_nr = rec_dump_search_tree(node->without, fp, next_node_nr + 1, st_env, (replace==0 && best_cost));
+               }
+       }
+
+       return(next_node_nr);
+}

diff --git a/ir/be/grgen/simd/search_tree.h b/ir/be/grgen/simd/search_tree.h
new file mode 100644 (file)
index 0000000..f31c56c
--- /dev/null
+++ b/ir/be/grgen/simd/search_tree.h
@@ -0,0 +1,20 @@
+/************************************************************************
+ * Program:            Search_tree.c
+ * Project:            SIMD optimization
+ * Function:   Provides functions to build a search tree to
+ *                             select the patterns for rewrite
+ * Author:             Andreas Schoesser
+ * Date:               2007-07-05
+ ************************************************************************/
+
+#ifndef __SEARCH_TREE_H__
+#define __SEARCH_TREE_H__
+
+#include "plist.h"
+
+#include "grs/match.h"
+#include "grs/matchplan.h"
+
+#include "search_tree_t.h"
+
+#endif

diff --git a/ir/be/grgen/simd/search_tree_t.h b/ir/be/grgen/simd/search_tree_t.h
new file mode 100644 (file)
index 0000000..bf263b6
--- /dev/null
+++ b/ir/be/grgen/simd/search_tree_t.h
@@ -0,0 +1,116 @@
+/************************************************************************
+* Program:             Search_tree.c
+* Project:             SIMD optimization
+* Function:            Provides functions to build a search tree to
+*                              select the patterns for rewrite
+* Author:              Andreas Schoesser
+* Date:                        2007-07-05
+************************************************************************/
+
+#ifndef __SEARCH_TREE_T_H__
+#define __SEARCH_TREE_T_H__
+
+#include "plist.h"
+#include "obstack.h"
+
+#include "grs/grs.h"
+#include "grs/match_t.h"
+#include "grs/matchplan.h"
+#include "grs/matchplan_t.h"
+
+#include "simd_opt_t.h"
+
+ext_grs_match_plan_t *mplans;
+
+#define THIS_MATCHS_COSTSAVINGS 3
+
+
+/** Entry of a ignore_match list */
+typedef struct
+{
+       pmap                    *nodes;
+       //ir_edge_t             **edges;
+} ignored_match_t;
+
+
+/** A node of the search tree */
+typedef struct search_tree_node_t
+{
+       ext_grs_match_t         *match;
+       int                                     which_match;
+       struct search_tree_node_t       *with;
+       struct search_tree_node_t       *without;
+       int                                                     cost_savings;
+       int                                                     this_matchs_costsavings;
+       int                                                     rule_nr;
+       struct pmap                                     *memory_preds;
+} search_tree_node_t;
+
+/** Information to delete vproj nodes again */
+typedef struct
+{
+       ir_node *vproj_node;
+       ir_node *org_result;
+} undo_vproj_t;
+
+/** Environment passed while building the search tree recursively */
+typedef struct
+{
+       ir_graph                                *irg;
+       int                                             num_rules;
+       ext_grs_match_plan_t    **m_plans;
+       int                                             *priorities;
+       ext_grs_action_t        **rules;
+       struct pmap                             *which_match_vproj;
+       struct pmap                             *replaced_ptrs;
+       char                                    **firmnode_names;
+       struct obstack                  *obst;
+       statistics_t                    *statistics;
+       int                                             *cost_savings;
+} search_tree_env_t;
+
+/** To be filled before replacement */
+typedef struct
+{
+       ir_graph                        *irg;
+       struct pmap                     *keep_nodes;
+       struct pmap                     *vec_operations;
+       struct pmap                     *which_match_vproj;
+       statistics_t            *statistics;
+       ext_grs_action_t    **rules;
+       char                            **firmnode_names;
+       struct obstack          *obst;
+} replace_st_env_t;
+
+typedef struct
+{
+       ext_grs_match_t *match;
+       int                             which;
+       int                             aiid;
+} which_match_vproj_t;
+
+
+// Public
+search_tree_node_t *build_search_tree(search_tree_env_t *search_tree_env, int prio_start);//, int struct pmap *vec_operations, struct pmap *keep_nodes, int start, statistics_t *statistics, struct pmap *replaced_ptrs)
+void replace_search_tree(search_tree_node_t *root, replace_st_env_t *rep_env);
+void destroy_search_tree(search_tree_node_t *root);
+
+// Private
+static search_tree_node_t *rec_search_patterns(search_tree_env_t *st_env, int prio, plist_t **ignored_matches);
+static plist_element_t *add_ignored_match(ext_grs_match_t *match, int which, plist_t **ignored_matches, int rule_nr);
+static void delete_ignored_match(plist_t **ignored_matches, plist_element_t *match_to_delete, int rule_nr);
+static int ignore_match(ext_grs_match_t *match, int which, plist_t **ignored_matches, int rule_nr);
+static plist_t *construct_vproj(search_tree_env_t *st_env, search_tree_node_t *st_node, int rule_nr);
+static void deconstruct_vproj(plist_t *undo_vproj_info);
+static void insert_which_match_vproj(search_tree_env_t *st_env, ir_node *vproj, ext_grs_match_t *match, int which, int aiid);
+static void manipulate_match(replace_st_env_t *rep_env, ext_grs_match_t *match, int which);
+
+void dump_search_tree(search_tree_node_t *root, char *file, char *graph_name, search_tree_env_t *st_env);
+int rec_dump_search_tree(search_tree_node_t *node, FILE *fp, int this_node_nr, search_tree_env_t *st_env, int best_cost);
+
+void insert_inner_nodes(search_tree_env_t *st_env, search_tree_node_t *st_node);
+void remove_inner_nodes(search_tree_env_t *st_env, search_tree_node_t *st_node);
+
+void set_complex_operation_block(ir_graph *irg, ext_grs_match_t *match, int which);
+
+#endif

diff --git a/ir/be/grgen/simd/simd_opt.c b/ir/be/grgen/simd/simd_opt.c
new file mode 100644 (file)
index 0000000..98b0cea
--- /dev/null
+++ b/ir/be/grgen/simd/simd_opt.c
@@ -0,0 +1,1183 @@
+/*******************************************************************************************
+ * Program:  simd_opt.c
+ * Function: Part of the simd optimization. Searches match of complex operation pattern and
+ *           inserts the complex operation if possible.
+ * Author:   Andreas Schoesser
+ * Date:     06.12.2006
+ *******************************************************************************************/
+
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <conio.h>
+
+#include "irgopt.h"
+#include "pmap.h"
+#include "obstack.h"
+
+#include "simd_opt_t.h"
+
+#include "firm_node_ext.h"
+#include "normalize.h"
+#include "search_tree_t.h"
+
+#ifdef INCLUDE_GENERATED_PATTERNS
+       #include "generated/simd_rules.h"
+#endif
+
+extern ir_op *grs_op_Complex;
+extern ext_grs_action_init_complex_instructions();
+
+#ifdef INCLUDE_GENERATED_PATTERNS
+       ext_grs_match_plan_t *m_plans[NUM_RULES];
+#endif
+
+
+/*          _                          _ _           _   _
+_ __  _   _| | ___    __ _ _ __  _ __ | (_) ___ __ _| |_(_) ___  _ __
+| '__| | | | |/ _ \  / _` | '_ \| '_ \| | |/ __/ _` | __| |/ _ \| '_ \
+| |  | |_| | |  __/ | (_| | |_) | |_) | | | (_| (_| | |_| | (_) | | | |
+|_|   \__,_|_|\___|  \__,_| .__/| .__/|_|_|\___\__,_|\__|_|\___/|_| |_|
+                                 |_|   |_|
+*/
+
+int srt_cmp(const void *v1, const void *v2)
+{
+       int *i1 = (int *) v1;
+       int *i2 = (int *) v2;
+
+       return  i1[1] - i2[1];
+}
+
+
+/************************************************************************/
+/* Performs the pattern lookup and pattern replacement if possible,     */
+/* for all actions defined by the user in the "create pattern" step.    */
+/************************************************************************/
+
+void ext_grs_simd_opt()
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+
+       ext_grs_planer_t *planer;
+       ext_grs_analyzer_t *analyzer;
+       char c;
+       int irg_nr, start;
+       statistics_t statistics;
+
+       memset(&statistics, 0, sizeof(statistics_t));
+       statistics.rewritten_patterns = alloca(NUM_RULES * sizeof(int));
+       memset(statistics.rewritten_patterns, 0, NUM_RULES * sizeof(int));
+
+       printf("\n\nSearching for rich instructions\n===============================\n\n");
+
+       statistics.start_time = clock();
+
+       // Insert additional FIRM nodes, like VProj
+       ext_firm_nodes();
+
+       // Init the actions
+       ext_grs_action_init_complex_instructions();
+       fill_rulename_array();
+
+       // "priorites" is a 2-dimensional array, containing
+       // [RULE_NUMBER][priority]
+       // Sort this array by priority here.
+       qsort((void *) &priorities, (size_t) NUM_RULES, ( size_t) (sizeof(int) * 2), srt_cmp);
+
+       // Set up the graph matcher
+       analyzer = ext_grs_get_vs_analyzer();
+       planer = ext_grs_get_vs_dmst_planer();
+
+       // Match defined rules.
+       // Rules are ordered by priority in the rules[] array.
+       for(irg_nr = get_irp_n_irgs() - 1; irg_nr >= 0; irg_nr--)
+       {
+               struct pmap *vec_operations = pmap_create(); /* Maps all created vector operations to their destination op */
+               struct pmap *keep_nodes = pmap_create();
+               ir_graph *irg = get_irp_irg(irg_nr);
+               struct pmap *norm_undo_info;
+
+               #if VERBOSE_REWRITE
+                       printf("\n ** Analyzing function %s **\n", get_entity_name(get_irg_entity(irg)));
+               #endif
+
+               current_ir_graph = irg;
+
+
+               // Dump the graph to see what it was like before the replacement
+               dump_ir_block_graph(irg, "-pre-simd");
+               remove_critical_cf_edges(irg);
+               norm_undo_info = normalize_address_calculation(irg, 1);
+               edges_deactivate(irg);
+               edges_activate(irg);
+
+
+               compute_match_plans(irg, planer, analyzer);
+
+               // Normal rewrite
+               //start = perform_rewrite(irg, vec_operations, keep_nodes, 0, &statistics, norm_undo_info);
+               start = perform_rewrite_experimental(irg, vec_operations, keep_nodes, 0, &statistics, norm_undo_info);
+               #if VERBOSE_REWRITE
+                       printf("\nRenaming complex operations...\n");
+               #endif
+               #if VERBOSE_REWRITE
+                       dump_ir_block_graph(irg, "-REWRITTEN0-PRE-IA23-NODES");
+               #endif
+
+               rename_complex_operations(vec_operations);
+               #if VERBOSE_REWRITE
+                               dump_ir_block_graph(irg, "-REWRITTEN1-IA23-NODES");
+               #endif
+               exchange_keep_nodes(keep_nodes);
+
+               // Rewriting may have left a mess of a graph behind, optimize control flow and ophaned LOADs
+
+               optimize_load_store(irg);
+               optimize_cf(irg);
+
+               #if VERBOSE_REWRITE
+                       dump_ir_block_graph(irg, "-REWRITTEN2-POST-LOAD-STORE-OPT");
+               #endif
+
+               edges_activate(irg); /* HACK! optimize_cf deactivates edges!! */
+
+               // Clean up the remaining vProjs
+               #if VERBOSE_REWRITE
+                       printf("\nClean-up step:");
+               #endif
+
+               pmap_destroy(vec_operations);
+               pmap_destroy(keep_nodes);
+               vec_operations = pmap_create(); /* Maps all created vector operations to their destination op */
+               keep_nodes = pmap_create();
+               perform_rewrite(irg, vec_operations, keep_nodes, start, &statistics, norm_undo_info);
+               rename_complex_operations(vec_operations);
+
+               exchange_keep_nodes(keep_nodes);
+
+               // Remove MultipleAdd nodes
+               #if VERBOSE_REWRITE
+                       printf("\nUndoing normalization...\n");
+               #endif
+               decompose_normalization(norm_undo_info);
+
+               #if VERBOSE_REWRITE
+                       dump_ir_block_graph(irg, "-REWRITTEN3-FINAL");
+               #endif
+
+               // Clean up data structures
+               pmap_destroy(vec_operations);
+               pmap_destroy(keep_nodes);
+               edges_deactivate(irg);
+       }
+       statistics.end_time = clock();
+
+       printf("\n ** Rewriting finished. **\n\n");
+
+       view_statistics(&statistics);
+#else
+
+       printf("SIMD optimization turned off...\n<--'\n");
+       getchar();
+       ext_firm_nodes();
+
+#endif
+}
+
+void compute_match_plans(ir_graph *irg, ext_grs_planer_t *planer, ext_grs_analyzer_t *analyzer)
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+       int rule_nr;
+
+       #if VERBOSE_REWRITE
+               printf("Computing search plans...\n");
+       #endif
+
+       ext_grs_init_planer(planer, analyzer);
+       ext_grs_enable_irg(irg); // Alloc memory in ir_graph for match analysis result.
+       ext_grs_analyze(analyzer, irg);
+
+       // This returns a newly allocated "matchplan" oject.
+       for(rule_nr = 0; rule_nr < NUM_RULES; rule_nr++)
+       {
+               m_plans[rule_nr] = ext_grs_compute_plan(planer, irg, rules[rule_nr]);
+
+               #if DUMP_SEARCH_PLAN
+                       ext_grs_dump_match_plan(m_plans[rule_nr]);
+               #endif
+       }
+#endif
+}
+
+
+
+/************************************************************************************
+ * Params:     irg: The ir graph to be optimized
+ *                     vec_operations: A pmap with all "Complex" nodes to be exchanged
+ *                                                     by ia32 nodes later
+ *                     keep_nodes:             A pmap containing the keep nodes to be inserted
+ *                     start:                  rule number to start with
+ *                     statistics:             Statistics structure to save statistics information in
+ *                     replaced_ptrs:  Addresses of Load and Store nodes replaced by MultipleAdd
+ *                                                     Nodes
+ ************************************************************************************/
+
+int perform_rewrite(ir_graph *irg, struct pmap *vec_operations, struct pmap *keep_nodes, int start, statistics_t *statistics, struct pmap *replaced_ptrs)
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+       int i, j;
+       ext_grs_match_t *match;
+       char c;
+
+       for(i = start; i < NUM_RULES; i++)
+       {
+               int rule_nr = priorities[i][0];
+               int num_matches;
+               char match_postfix[100];
+               j = 0;
+
+               if(priorities[i][1] > 1000 && start == 0)
+                       break;
+
+                       do
+                       {
+                               #if VERBOSE_REWRITE
+                                       printf("\nApplying RULE %s: ", firmnode_names[rule_nr]);
+                               #endif
+
+                               // This returns a newly allocated "matchplan" oject.
+                               //m_plan = ext_grs_compute_plan(planer, irg, rules[rule_nr]); */
+
+                               #if DUMP_SEARCH_PLAN
+                                       ext_grs_dump_match_plan(m_plans[rule_nr]);
+                               #endif
+
+                               // Match the pattern given in the action inited above
+                               // Compliant: Only NON-overlapping matches allowed.
+                               // TODO: Describe case of overlapping patterns. Which to chose? Point to backend implementations
+                               match = ext_grs_match(irg, m_plans[rule_nr], ext_grs_ALL, ext_grs_COMPLIANT);
+                               statistics->num_matches++;
+                               statistics->num_matched_nodes += match->n_nodes;
+
+                               #if VERBOSE_REWRITE
+                                       printf(" Found matches is %d.", ext_grs_get_n_matches(match));
+                                       sprintf(match_postfix, "-MATCHED-%d-%d", i, j);
+                                       ext_grs_dump_match(match, match_postfix);
+                               #endif
+
+                               // Look if a match has been found
+                               num_matches = ext_grs_get_n_matches(match);
+                               if(num_matches > 0)
+                               {
+                                       struct pmap *memory_preds;
+                                       // Do alias analysis and "LOAD usage" analysis" to see if pattern is really appliable.
+
+                                       if(analyze_arguments(rules[rule_nr], match, 0, irg, NULL) < 0)
+                                       {
+                                               #if VERBOSE_REWRITE
+                                                       printf(" Invalid arguments.");
+                                               #endif
+                                       }
+                                       else
+                                       {
+
+                                               // Find the memory predecessors to be able to schedule the complex operation
+                                               memory_preds = find_memory_preds(irg, ext_grs_get_match_node_map(match, 0), rules[rule_nr]->max_node_aiid);
+
+                                               if(test_alias_relation(match->nodes[0], match->max_node_id, memory_preds, replaced_ptrs) == 0)
+                                               {
+                                                       // Everything seems ok, do the rewrite
+                                                       #if VERBOSE_REWRITE
+                                                               printf(" Rewrite? (y/n) ");
+                                                               #if PROMPT_REWRITE
+                                                                       c = getch();
+                                                               #else
+                                                                       c = 'y';
+                                                                       printf("y");
+                                                               #endif
+                                                       #else
+                                                               c = 'y';
+                                                       #endif
+
+                                                       if(c == 'y' || c == 'Y')
+                                                       {
+                                                               // Do the rewriting step. Rewrite ALL matches (for now...).
+                                                               int which[5] = { 0, 1, 2, 3, 4 };
+                                                               ext_grs_finish_match(match, 1, &which[0]);
+                                                               connect_complex_memory(rules[rule_nr], match, 0, memory_preds);
+                                                               save_complex_operation(rules[rule_nr], match, 0, vec_operations, rule_nr);
+                                                               save_keep_nodes(rules[rule_nr], match, 0, keep_nodes);
+                                                               sprintf(match_postfix, "-REWRITTEN-%d-%d", i, j);
+                                                               dump_ir_block_graph(irg, match_postfix);
+                                                               statistics -> num_instructions_inserted++;
+                                                               statistics -> num_replaced_nodes += match->n_nodes;
+                                                               statistics -> rewritten_patterns[rule_nr]++;
+                                                       }
+                                                       else
+                                                       {
+                                                               num_matches = 0;
+                                                       }
+                                               }
+                                               else
+                                               {
+                                                       #if VERBOSE_REWRITE
+                                                               printf("Rejected. ");
+                                                       #endif
+                                               }
+                                       }
+                                       ext_grs_free_match(match);
+                               }
+#if PROMPT_NO_PATTERN_FOUND
+                               else
+                                       getch();
+#endif
+                       //ext_grs_disable_irg(irg); // Free analysis memory
+                       j++;
+               } while(num_matches > 0);
+       }
+       return(i);
+#endif
+}
+
+
+int perform_rewrite_experimental(ir_graph *irg, struct pmap *vec_operations, struct pmap *keep_nodes, int start, statistics_t *statistics, struct pmap *replaced_ptrs)
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+       search_tree_env_t st_env;
+       replace_st_env_t  rep_env;
+       search_tree_node_t *root;
+       int rule_nr = start;
+       struct obstack obst;
+
+       obstack_init(&obst);
+
+       while(rule_nr < NUM_RULES && priorities[rule_nr][1] != PRIORITY_CLEANUP)
+       {
+               int old_rulenr = rule_nr;
+
+               // Build the search tree
+               st_env.irg = irg;
+               st_env.priorities = (int *) &priorities[rule_nr];
+               st_env.m_plans = m_plans;
+               st_env.num_rules = NUM_RULES;
+               st_env.rules = rules;
+               st_env.which_match_vproj = pmap_create();
+               st_env.replaced_ptrs = replaced_ptrs;
+               st_env.firmnode_names = firmnode_names;
+               st_env.obst = &obst;
+               st_env.statistics = statistics;
+               st_env.cost_savings = cost_savings;
+               root = build_search_tree(&st_env, priorities[rule_nr][1]);
+
+               // Rewrite using search tree we built:
+               rep_env.irg = irg;
+               rep_env.keep_nodes = keep_nodes;
+               rep_env.vec_operations = vec_operations;
+               rep_env.statistics = statistics;
+               rep_env.rules = rules;
+               rep_env.which_match_vproj = st_env.which_match_vproj;
+               rep_env.firmnode_names = firmnode_names;
+               rep_env.obst = &obst;
+               replace_search_tree(root, &rep_env);
+
+               // Destroy the search tree
+               destroy_search_tree(root);
+               pmap_destroy(st_env.which_match_vproj);
+
+               //dump_irgraph_complete_grgen(current_ir_graph);
+
+               // Search rule with next higher priority to start the next search with
+               while(rule_nr < NUM_RULES && priorities[rule_nr][1] == priorities[old_rulenr][1])
+                       rule_nr++;
+       }
+
+       // TODO: Return the rule_nr up to which we searched
+       // This will be used in a second step to search for the rest of the
+       // rules which are cleanup operations
+       obstack_free(&obst, NULL);
+       obstack_finish(&obst);
+       return(rule_nr);
+#endif
+}
+
+
+
+/************************************************************************
+ * View statistics about the rewrite
+ ************************************************************************/
+
+static void view_statistics(statistics_t *statistics)
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+       int i;
+
+       printf("***************************\n* Optimization Statistics *\n***************************\n\n\n");
+       printf("Rich instructions inserted: %d\n", statistics->num_instructions_inserted);
+       printf("Matches:                    %d\n", statistics->num_matches);
+       printf("Nodes matched:              %d\n", statistics->num_matched_nodes);
+       printf("Nodes probably replaced:    %d\n", statistics->num_replaced_nodes);
+       printf("Time elapsed:               %g s\n", ((double) (statistics->end_time - statistics->start_time)) / CLOCKS_PER_SEC);
+
+       printf("\nReplaced patterns:\n");
+       for(i = 0; i < NUM_RULES; i++)
+       {
+               if(statistics->rewritten_patterns[i] > 0)
+                       printf("  %3dx %s\n", statistics->rewritten_patterns[i], firmnode_names[i]);
+       }
+
+       printf("\n\nPress <--' to generate code.");
+       getchar();
+#endif
+}
+
+
+
+
+/*                                                                                                                        _           _
+ _ __ ___   ___ _ __ ___   ___  _ __ _   _    __ _ _ __   __ _| |_   _ ___(_)___
+| '_ ` _ \ / _ \ '_ ` _ \ / _ \| '__| | | |  / _` | '_ \ / _` | | | | / __| / __|
+| | | | | |  __/ | | | | | (_) | |  | |_| | | (_| | | | | (_| | | |_| \__ \ \__ \
+|_| |_| |_|\___|_| |_| |_|\___/|_|   \__, |  \__,_|_| |_|\__,_|_|\__, |___/_|___/
+                                                            |___/                       |___/
+*/
+
+#if 0
+
+/* This is used when we have parallel memory edges */
+
+/************************************************************************/
+/* Tests, if two operations using the memory edge are                   */
+/* 0: parallel regarding the memory edge                                */
+/* 1: node b is above node a regarding the memory edge                  */
+/* 2: node a is above node b regarding the memory edge                  */
+/************************************************************************/
+
+int test_mem_rel(ir_node *a, ir_node *b)
+{
+       ir_graph *irg = get_irn_irg(get_nodes_block(a));
+       inc_irg_visited(irg);
+
+       if(search_mem_node(b, a, irg))
+               return(1); // b is above a
+
+       if(search_mem_node(a, b, irg))
+               return(2); // a is above b
+
+       return(0);     // nodes are parallel
+
+
+}
+
+int search_mem_node(ir_node *n, ir_node *start, ir_graph *irg)
+{
+       int i, found = 0;
+
+       if(get_irn_visited(start) == get_irg_visited(irg))
+               return(0);
+
+       set_irn_visited(start, get_irg_visited(irg));
+
+       if(start == n);
+               return(1); // Found it!
+
+       // Walk up the memory chain
+       if(get_irn_mode(start) == mode_M)
+       {
+               for(i = 0; i < get_irn_arity(start) && found == 0; i++)
+                       found |= search_mem_node(n, get_irn_n(start, i), irg);
+       }
+       else
+       {
+               for(i = 0; i < get_irn_arity(start) && found == 0; i++)
+               {
+                       ir_node *pred = get_irn_n(start, i);
+                       if(get_irn_mode(pred) == mode_M)
+                                found |= search_mem_node(n, get_irn_n(start, i), irg);
+               }
+       }
+
+       return(found);
+}
+#endif
+
+
+
+
+/************************************************************************
+ * Finds all pattern nodes, which are scheduled first
+ * The indicator of this is that these nodes have a memory-predecessor
+ * which lies outside of the pattern and there is no pattern node
+ * scheduled 'above' that predecessor. We call those nodes
+ * 'incoming memory nodes'
+ ************************************************************************/
+
+struct pmap *find_memory_preds(ir_graph *irg, ir_node **match_node_map, int max_node_aiid)
+{
+       mem_preds_info_t mem_preds_info;  // Holds analysis information during the firm walk
+       ir_node *start = get_irg_start(irg);
+       inc_irg_visited(irg);
+
+       mem_preds_info.pattern_nodes = generate_nodemap_hash(match_node_map, max_node_aiid); // Generate a hash out of the nodemap array for faster access
+       mem_preds_info.memory_preds = pmap_create(); // Save the memory predecessors we will find during the firm walk here
+       mem_preds_info.irg = irg;                    // Hand the irg over to the firm walker
+
+       visit_mem_nodes(start, &mem_preds_info);
+
+       // Return the 'incoming memory nodes' that we found.
+       pmap_destroy(mem_preds_info.pattern_nodes);
+       return(mem_preds_info.memory_preds);
+
+}
+
+static void visit_mem_nodes(ir_node *node, mem_preds_info_t *mem_preds_info)
+{
+       ir_graph *irg = mem_preds_info->irg;
+
+       if(irn_visited(node))
+               return;
+       set_irn_visited(node, get_irg_visited(irg));
+
+       // The end node is matched, but not really part of the pattern. Only needed to connect
+       // keep nodes to. So Skip the end node when searching memory predecessors
+       if(get_irn_opcode(node) == iro_End)
+               return;
+
+       // Falls in pattern nodes-> return;
+       if(pmap_contains(mem_preds_info->pattern_nodes, node))
+       {
+               pmap_insert(mem_preds_info->memory_preds, node, (void *) pmap_get(mem_preds_info->pattern_nodes, node) /*=aiid*/);
+               return;
+       }
+
+       if(get_irn_mode(node) == mode_M)
+       {
+               const ir_edge_t *edge;
+               foreach_out_edge(node, edge)
+                       visit_mem_nodes(get_edge_src_irn(edge), mem_preds_info);
+       }
+       else
+       {
+               const ir_edge_t *edge;
+               foreach_out_edge(node, edge)
+               {
+                       ir_node *tgt = get_edge_src_irn(edge);
+                       if(tgt != NULL && get_irn_mode(tgt) == mode_M)
+                               visit_mem_nodes(tgt, mem_preds_info);
+               }
+       }
+}
+
+
+
+
+/************************************************************************
+ * Find and return the memory in edge of a given node
+ * Returns the in-array index for the edge in edge_nr
+ * CAUTION: Seems not to work for PHI nodes!!!!!!!!!!!!!!!!!!!!!
+ ************************************************************************/
+
+static ir_node *find_memory_pred(ir_node *n, int *edge_nr, int start_edge)
+{
+       int i;
+       ir_node *mem_pred = NULL;
+
+       // Look for ProjMs. ProjM's predecessors don't have the "mode M".
+       if(get_irn_arity(n) == 1 && get_irn_modecode(n) == irm_M && start_edge == 0)
+       {
+               if(edge_nr != NULL)
+                       *edge_nr = 0;
+               return(get_irn_n(n, 0));
+       }
+
+       // It's not a ProjM node. Look for a predecessor with "mode_M".
+       for(i = start_edge; i < get_irn_arity(n); i++)
+       {
+               ir_node *pred = get_irn_n(n, i);
+               if(get_irn_modecode(pred) == irm_M /*&& get_irn_opcode(pred) != iro_NoMem <-- Do we really need this? */)
+               {
+                       if(edge_nr != NULL)
+                               *edge_nr = i;
+                       return(pred);
+               }
+       }
+       return(NULL);
+}
+
+
+
+/************************************************************************
+ * Generates a hash map out of a node_map array to have faster
+ * access on matched nodes later.
+ ************************************************************************/
+
+struct pmap *generate_nodemap_hash(ir_node **node_map, int max_node_aiid)
+{
+       struct pmap *node_hash = pmap_create();
+       int i;
+
+       for(i = 0; i <= max_node_aiid; i++)
+               if(node_map[i])
+                       pmap_insert(node_hash, node_map[i], (void *) i);
+       return(node_hash);
+}
+
+
+
+/***************************************************************************
+ * Returns the first predecessor nr, that is an Bad node, -2 otherwise
+ ***************************************************************************/
+
+static int find_bad_node(ir_node *n)
+{
+       int in_pos = -2, i;
+
+       for(i = 0; i < get_irn_arity(n); i++)
+               if(get_irn_opcode(get_irn_n(n, i)) == iro_Bad)
+                       return(i);
+
+       return(in_pos);
+}
+
+
+
+/*
+    _    _ _             ____      _       _   _
+   / \  | (_) __ _ ___  |  _ \ ___| | __ _| |_(_) ___  _ __
+  / _ \ | | |/ _` / __| | |_) / _ \ |/ _` | __| |/ _ \| '_ \
+ / ___ \| | | (_| \__ \ |  _ <  __/ | (_| | |_| | (_) | | | |
+/_/   \_\_|_|\__,_|___/ |_| \_\___|_|\__,_|\__|_|\___/|_| |_| */
+
+
+/************************************************************************
+ * Starts the alias check for each node of the pattern
+ * Returns: 1 if pattern is not appliable due to alias conflicts
+ *          0 if the pattern is appliable
+ ************************************************************************/
+
+int test_alias_relation(ir_node **node_map, int max_node_aiid, struct pmap *memory_preds, struct pmap *replaced_ptrs)
+{
+       struct pmap *node_map_hash = generate_nodemap_hash(node_map, max_node_aiid);
+       int i;
+
+       for(i = 0; i < max_node_aiid; i++)
+               if(node_map[i])
+               {
+                       int edge_nr = -1;
+                       ir_node *pred;
+
+                       while((pred = find_memory_pred(node_map[i], &edge_nr, edge_nr + 1)))
+                       {
+                               if(walk_mem_edge_alias(node_map[i], pred, memory_preds, node_map_hash, replaced_ptrs) == 1)
+                                       return(1);
+                       }
+               }
+       return(0);
+}
+
+
+/************************************************************************
+ * For a specific pattern node: Walks up the memory edge until start or
+ * a memory predecessor of the pattern is reached and checks each memory
+ * node found for alias relation
+ * How can start be reached? Should not happen IMO.
+ ************************************************************************/
+
+static int walk_mem_edge_alias(ir_node *orgn, ir_node *cn, struct pmap *memory_preds, struct pmap *node_map_hash, struct pmap *replaced_ptrs)
+{
+       int edge_nr = -1;
+       ir_node *pred;
+
+       if(pmap_contains(memory_preds, orgn))
+               return(0);
+
+       if(pmap_contains(node_map_hash, cn))
+       {
+               if(get_multadd_alias_relation(orgn, cn) != no_alias) //check_alias(orgn, cn, replaced_ptrs) != no_alias)
+               {
+                       if(get_irn_opcode(orgn) != iro_Store || get_irn_opcode(cn) == iro_Load)
+                               return(1); // Bad
+                       // go on otherwise, STORE after LOAD allowed
+               }
+       }
+
+       // We reached a memory pred or the start node?
+       if(pmap_contains(memory_preds, cn) || get_irn_opcode(cn) == iro_Start) // Caution, memory preds are inside the pattern
+               return(0);
+
+       // Check if the two nodes alias
+       if(!pmap_contains(node_map_hash, cn))
+       {
+               if(get_multadd_alias_relation(orgn, cn) != no_alias) //check_alias(orgn, cn, replaced_ptrs) != no_alias)
+                       return(1);
+       }
+
+       // Walk on
+       while((pred = find_memory_pred(cn, &edge_nr, edge_nr + 1)))
+               if(walk_mem_edge_alias(orgn, pred, memory_preds, node_map_hash, replaced_ptrs) == 1)
+                       return(1);
+
+       // Checked all paths and did not find an alias conflict, so return 0
+       return(0);
+}
+
+
+/************************************************************************
+ * Checks if 2 nodes of kind LOAD or STORE alias. Uses the old addresses
+ * instead of the MultipleAdd used for normalization
+ ************************************************************************/
+
+static ir_alias_relation check_alias(ir_node *n1, ir_node *n2, struct pmap *replaced_ptrs)
+{
+       ir_node *addr1 = NULL, *addr2 = NULL, *org_addr1, *org_addr2;
+       ir_mode *mode1, *mode2;
+
+       switch(get_irn_opcode(n1))
+       {
+               case iro_Store: addr1 = get_Store_ptr(n1); mode1 = get_irn_mode(get_Store_value(n1)); break;
+               case iro_Load:  addr1 = get_Load_ptr(n1);  mode1 = mode_F; /* Hack */ break;
+               default: return(no_alias);
+       }
+
+       switch(get_irn_opcode(n2))
+       {
+               case iro_Store: addr2 = get_Store_ptr(n2); mode2 = get_irn_mode(get_Store_value(n1)); break;
+               case iro_Load:  addr2 = get_Load_ptr(n2);  mode2 = mode_F; /* Hack */break;
+               default: return(no_alias);
+       }
+
+       org_addr1 = get_org_addr(addr1, replaced_ptrs);
+       org_addr2 = get_org_addr(addr2, replaced_ptrs);
+
+       return(get_alias_relation(current_ir_graph, org_addr1, mode1, org_addr2, mode2));
+}
+
+
+
+/*  _                                         _                       _           _
+   / \   _ __ __ _ _   _ _ __ ___   ___ _ __ | |_    __ _ _ __   __ _| |_   _ ___(_)___
+  / _ \ | '__/ _` | | | | '_ ` _ \ / _ \ '_ \| __|  / _` | '_ \ / _` | | | | / __| / __|
+ / ___ \| | | (_| | |_| | | | | | |  __/ | | | |_  | (_| | | | | (_| | | |_| \__ \ \__ \
+/_/   \_\_|  \__, |\__,_|_| |_| |_|\___|_| |_|\__|  \__,_|_| |_|\__,_|_|\__, |___/_|___/
+                         |___/                                                      |___/
+*/
+
+
+/************************************************************************
+ * Looks, if a argument node is in a block that dominates the block
+ * the complex node has to be inserted to!
+ * Return: 0 if so
+ *        -1 if the arguments are not in a dominator, which is illegal
+ *               -2 if an argument is mem dependent of an inner pattern node
+ * TODO: Analyse where to put the complex operation first! Now we do that
+ *       by hand!
+ ************************************************************************/
+
+int analyze_arguments(ext_grs_action_t *action, ext_grs_match_t *match, int which, ir_graph *irg, struct pmap *memory_preds)
+{
+       char arg_name[100];
+       int  arg_aiid, i, block_aiid;
+       ir_node **node_map = ext_grs_get_match_node_map(match, which);
+       ir_node *arg, *block, *arg_block;
+       struct pmap *node_map_hash = generate_nodemap_hash(ext_grs_get_match_node_map(match, which), ext_grs_get_match_max_node_aiid(match));
+
+       block_aiid = ext_grs_act_get_node_aiid(action, COMPLEX_OPERATION_BLOCK_NAME);
+       assert(block_aiid > 0 && "Block of complex operations has not been dumped!");
+       block = node_map[block_aiid];
+       assert(get_irn_opcode(block) == iro_Block);
+
+       for(i = 0; ; i++)
+       {
+               sprintf(arg_name, "Arg_%d", i);
+               arg_aiid = ext_grs_act_get_node_aiid(action, arg_name);
+               if(arg_aiid < 0)
+                       break;                  // All arguments have been processed.
+
+               // Retrieve the node corresponding to an argument and check it for consistency
+               arg = node_map[arg_aiid];
+
+               if(is_arg_mem_dependent(arg, node_map_hash))
+               {
+                       pmap_destroy(node_map_hash);
+                       return(-2);
+               }
+
+
+               // First check if the argument is dependent from inner pattern nodes
+               arg_block = get_nodes_block(arg);
+               assert(get_irn_opcode(arg_block) == iro_Block);
+
+               if(arg_block == block)
+                       continue;
+
+               assure_doms(irg);
+               if(block_dominates(arg_block, block))
+                       continue;
+
+               pmap_destroy(node_map_hash);
+               return(-1); // Argument not in dominator of complex operation block! It's unsafe to rewrite.
+       }
+
+       pmap_destroy(node_map_hash);
+       return(0); // Everything is ok, match can be rewritten
+}
+
+
+
+/**************************************************************************
+* Looks if a Argument node of the complex node is memory dependent of any
+* memory node of the pattern. This would lead to a dead lock and has to
+* be prevented.
+**************************************************************************/
+
+int is_arg_mem_dependent(ir_node *arg, struct pmap *node_map_hash)
+{
+       argdep_ana_info_t ana_info;
+
+       // First find out the highest block in dom tree
+
+       // First start firm walker up till
+       // - a memory nodes is reached
+       // - or we reached the highest dom block
+       ana_info.found_dependency = 0;
+       ana_info.node_map_hash = node_map_hash;
+       irg_walk(arg, walk_arg_dep, NULL, &ana_info);
+
+       return(ana_info.found_dependency);
+
+
+       // For all mem nodes we reached
+       // Walk up mem edge
+       // Check if we hit an inner pattern node. If so: error!
+
+       // Problems: Mem edge walker: Phis? Sync? Have to walk all ways
+}
+
+
+
+/************************************************************************
+ *
+ ************************************************************************/
+
+static void walk_arg_dep(ir_node *n, void * env)
+{
+       // If n is a memory node, start walking up only all memory edges incident to this node
+       int edge_nr = -1;
+       argdep_ana_info_t *ana_info = env;
+       ir_node *pred;
+
+       // Dependency has been found on another path. Break walker
+       if(ana_info->found_dependency)
+       {
+               for(edge_nr = (is_Block(n)) ? 0 : -1; edge_nr < get_irn_arity(n); edge_nr++)
+                       set_irn_visited(get_irn_n(n, edge_nr), get_irg_visited(get_irn_irg(n)));
+               return;
+       }
+
+       // If we have a memory node, walk up memory edge(s) and don't touch the above data preds
+       while((pred = find_memory_pred(n, &edge_nr, edge_nr + 1)))
+//             if(ana_info->found_dependency == 0)
+                       if(walk_mem_edge_argdep(pred, ana_info->node_map_hash) == 1)
+                       {
+                               ana_info->found_dependency = 1;
+                               break;
+                       }
+}
+
+
+
+/************************************************************************
+ * Walks up the memory edge for argument dependency analysis
+ ************************************************************************/
+
+int walk_mem_edge_argdep(ir_node *n, struct pmap *node_map_hash)
+{
+       int edge_nr = -1;
+       ir_node *pred;
+
+       if(get_irn_visited(n) == get_irg_visited(get_irn_irg(n)))
+               return(0);
+       set_irn_visited(n, get_irg_visited(get_irn_irg(n)));
+
+       // Did we reach a pattern node?
+       if(pmap_contains(node_map_hash, n))
+               return(1);                                                      // Yes
+
+       // TODO: Check if max dominator reached
+       // TODO: Check if we walked over a backedgemake
+
+
+       // Walk on
+       while((pred = find_memory_pred(n, &edge_nr, edge_nr + 1)))
+               if(walk_mem_edge_argdep(pred, node_map_hash) == 1)
+                       return(1);
+
+       return(0);                                                              // We reached no pattern node, everything ok
+}
+
+
+
+/*         _                                        _ _
+  _____  _| |_ ___ _ __ _ __    _ __ ___  ___ _   _| | |_
+ / _ \ \/ / __/ _ \ '__| '_ \  | '__/ _ \/ __| | | | | __|
+|  __/>  <| ||  __/ |  | | | | | | |  __/\__ \ |_| | | |_
+ \___/_/\_\\__\___|_|  |_| |_| |_|  \___||___/\__,_|_|\__| */
+
+/************************************************************************
+ * Computes the additional costs that arise when pattern nodes have to
+ * be maintained due to external usage nodes outside the pattern
+ * We just compute the costs of THAT single node
+ ************************************************************************/
+
+int ext_result_costs(ext_grs_match_t *match, int which)
+{
+       ir_node **nodes = ext_grs_get_match_node_map(match, which);
+       int maxid = ext_grs_get_match_max_node_aiid(match), i;
+       struct pmap *node_map_hash = generate_nodemap_hash(nodes, maxid);
+       int add_costs = 0;
+
+       for(i = 0; i < maxid; i++) // Iterate through all pattern nodes
+       {
+               if(match->action->nodes[i]->op != op_IrNode)  // Node is not one of the generic vector base nodes. Those stay in the graph anyway.
+               {
+                       // Has the node been matched and is the node NOT a Result of the Pattern?
+                       if(nodes[i] && strncmp(match->action->nodes[i]->name, VECTOR_RESULT_NAME, strlen(VECTOR_RESULT_NAME)) != 0 && strncmp(match->action->nodes[i]->name, "Arg_", 4) != 0)
+                       {
+                               if(get_irn_modecode(nodes[i]) != irm_M && get_irn_opcode(nodes[i]) != iro_Const && get_irn_opcode(nodes[i]) != iro_Block && get_irn_opcode(nodes[i]) != iro_VProj) // Memory result not interesting here
+                               {
+                                       ir_edge_t *edge;
+                                       foreach_out_edge(nodes[i], edge) // Look at all out edges of the pattern node
+                                       {
+                                               if(get_irn_modecode(edge->src) != irm_M) // Memory result not interesting here
+                                               {
+                                                       if(!pmap_contains(node_map_hash, edge->src))    // Look, if the source of the out edge is outside the pattern
+                                                               add_costs += single_node_costs(edge->src);
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+
+       pmap_destroy(node_map_hash);
+       return(add_costs);
+}
+
+
+
+/************************************************************************
+ * Returns the costs for each individual FIRM node type.
+ * Returns always 3 for now.
+ ************************************************************************/
+
+int single_node_costs(ir_node *n)
+{
+       return(3);
+}
+
+
+
+
+/*                              _                    _                                     _
+ _ __   ___  ___| |_   _ __ ___ _ __ | | __ _  ___ ___ _ __ ___   ___ _ __ | |_
+| '_ \ / _ \/ __| __| | '__/ _ \ '_ \| |/ _` |/ __/ _ \ '_ ` _ \ / _ \ '_ \| __|
+| |_) | (_) \__ \ |_  | | |  __/ |_) | | (_| | (_|  __/ | | | | |  __/ | | | |_
+| .__/ \___/|___/\__| |_|  \___| .__/|_|\__,_|\___\___|_| |_| |_|\___|_| |_|\__|
+|_|                            |_|
+*/
+
+/************************************************************************
+ * Connect the complex operation with the memory edge
+ ************************************************************************/
+
+void connect_complex_memory(ext_grs_action_t *action, ext_grs_match_t *match, int which, struct pmap *mem_preds)
+{
+       ir_node **repl_node_map = ext_grs_get_replace_node_map(match, which);
+       int vop_aiid = ext_grs_act_get_node_aiid(action, VECTOR_OP_NAME); // Find the vector operation
+       int vop_projm_aiid = ext_grs_act_get_node_aiid(action, VECTOR_OP_PROJM_NAME); // Find it's ProjM node
+       ir_node *vec, *projm;
+       ir_node *memory_base = NULL;
+       pmap_entry *entry;
+       int i = 0;
+
+
+       // The complex node needs the memory edge, if it has a ProjM node attached.
+       if(vop_projm_aiid > -1)
+       {
+               // ProjM is there: Connect the Memory edge
+               assert(vop_aiid > -1 && "Vector operation not found!");
+               vec = repl_node_map[vop_aiid];
+               projm = repl_node_map[vop_projm_aiid];
+
+               // Mem_preds are the nodes INSIDE the pattern. Check their successors and
+               // look if its always the same. Well, this loop makes no sense right now
+               // it assumes that there is only 1 mem_pred (Speichereingaenger) and therefore
+               // also one one Speichervorgaenger.
+               pmap_foreach(mem_preds, entry)
+               {
+                       ir_node *n; // = entry->key;
+                       int     aiid = (int) entry->value;
+                       ir_node *vop_mem_pred;
+                       int edge_nr = 0, bad_nr = 0;
+
+                       // Find the right n if n was replaced
+                       n = repl_node_map[action->pattern_node_kept[aiid]];
+
+                       if(memory_base == NULL)
+                               memory_base = n;
+                       if(n != memory_base)
+                               assert(0 && "Parallel incoming memory edges with different roots not supported right now. Need to SYNC...");
+
+                       assert(get_irn_opcode(n) != iro_Phi && "Incoming Mem node is a PHI. Strange.");
+                       vop_mem_pred = find_memory_pred(n, &edge_nr, 0);
+                       assert(vop_mem_pred != NULL && "Incoming memory node should have a memory edge!");
+                       bad_nr = find_bad_node(vec);
+                       assert(bad_nr >= 0 && "Dummy slot for connecting the Mem edge not found!");
+                       set_irn_n(vec, bad_nr, vop_mem_pred);  // Connect the vector op with its memory predecessor
+                       set_irn_n(n, edge_nr, projm);
+               }
+       }
+
+       /*sprintf(keep_name, "IR_Keep%d", i);
+       while((keep_aiid = ext_grs_act_get_node_aiid(action, keep_name)) > -1)
+       {
+               ir_node *keep, *new_keep;
+               ir_node **ins;
+
+               // Find the keep node
+               keep = repl_node_map[keep_aiid];
+               ins = get_irn_in(keep);
+               new_keep = be_new_Keep(NULL, get_irn_irg(keep), get_nodes_block(keep), get_irn_arity(keep), &ins[1]);
+               exchange(keep, new_keep);
+
+               //add_register_req(keep);
+
+               sprintf(keep_name, "be_Keep%d", ++i);
+       }*/
+}
+
+
+/************************************************************************
+ * Called for each "Complex" node inserted into the graph.
+ * Saves all complex operations that have been inserted into a ir_graph.
+ * After no additional match can be found in the current ir_graph,
+ * the saved operations are exchanged by their backend nodes.
+ ************************************************************************/
+
+void save_complex_operation(ext_grs_action_t *action, ext_grs_match_t *match, int which, struct pmap *vec_operations, int nr)
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+       ir_node **repl_node_map = ext_grs_get_replace_node_map(match, which);
+       int vop_aiid = ext_grs_act_get_node_aiid(action, VECTOR_OP_NAME); // Find it's ProjM node
+       ir_node *vec = repl_node_map[vop_aiid];
+
+       pmap_insert(vec_operations, vec, ia32_construct_funcs[nr]);
+#endif
+}
+
+
+
+/*************************************************************************
+ * Saves the intermediate keep nodes along with their complex operations
+ * so that they can be exchanged by real be_nodes later.
+ *************************************************************************/
+
+void save_keep_nodes(ext_grs_action_t *action, ext_grs_match_t *match, int which, struct pmap *keep_nodes)
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+       ir_node **repl_node_map = ext_grs_get_replace_node_map(match, which);
+       char keep_name[255];
+       int keep_aiid, i = 0;
+       int vop_aiid = ext_grs_act_get_node_aiid(action, VECTOR_OP_NAME); // Find it's ProjM node
+       ir_node *vec = repl_node_map[vop_aiid];
+
+       sprintf(keep_name, "IR_Keep%d", i);
+       while((keep_aiid = ext_grs_act_get_node_aiid(action, keep_name)) > -1)
+       {
+               ir_node *keep = repl_node_map[keep_aiid];
+
+               pmap_insert(keep_nodes, keep, vec);  // Save the keep node and link to it's complex operation
+               sprintf(keep_name, "be_Keep%d", ++i);
+       }
+#endif
+}
+
+
+/************************************************************************
+ * Renames the complex operation to its destination op
+ ************************************************************************/
+
+void rename_complex_operations(struct pmap *vec_operations)
+{
+#ifdef INCLUDE_GENERATED_PATTERNS
+       pmap_entry *entry;
+
+       pmap_foreach(vec_operations, entry)
+       {
+               const ir_node *c_vec = entry -> key;
+               ir_node *vec = (ir_node *) c_vec;
+               ir_node *ben;
+               ia32_construct_func_t ia32_construct_func = entry -> value;
+
+               switch(get_irn_arity(vec))
+               {
+                       case 1:
+                               // ir_node *new_rd_ia32_vadd_2_32(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
+                               ben = ia32_construct_func(NULL, get_irn_irg(get_nodes_block(c_vec)), get_nodes_block(c_vec), get_irn_n(c_vec, 0), get_irn_mode(c_vec));
+                               exchange(vec, ben);
+                               break;
+
+                       case 2:
+                               ben = ia32_construct_func(NULL, get_irn_irg(get_nodes_block(c_vec)), get_nodes_block(c_vec), get_irn_n(c_vec, 0), get_irn_n(c_vec, 1), get_irn_mode(c_vec));
+                               exchange(vec, ben);
+                               break;
+
+                       case 3:
+                               {
+                                       ir_graph *irg;
+                                       ir_node *block, *op1, *op2, *op3;
+                                       ir_mode *mode;
+
+                                       block = get_nodes_block(vec);
+                                       irg = get_irn_irg(block);
+                                       op1 = get_irn_n(c_vec, 0);
+                                       op2 = get_irn_n(c_vec, 1);
+                                       op3 = get_irn_n(c_vec, 2);
+                                       mode = get_irn_mode(vec);
+
+                                       ben = ia32_construct_func(NULL, irg, block, op1, op2, op3, mode);
+                                       exchange(vec, ben);
+                               }
+                               break;
+                       default: assert(0 && "This arity is not supported!");
+               }
+               //set_irn_op(vec, op);
+       }
+#endif
+}
+
+
+/************************************************************************
+ * Exchanges the intermediate keep nodes by real be_Keep nodes, asking
+ * the complex operation for the register constraints.
+ ************************************************************************/
+
+static void exchange_keep_nodes(struct pmap *keep_nodes)
+{
+       pmap_entry *entry;
+
+       pmap_foreach(keep_nodes, entry)
+       {
+               ir_node *keep = (ir_node *) entry->key;
+               ir_node *vec_op;
+               ir_node *new_keep, **ins;
+
+               // TODO: Ask the vecop for register constraints.
+               vec_op = get_irn_n(get_irn_n(keep, 0), 0);
+
+               ins = get_irn_in(keep);
+               new_keep = be_new_Keep(NULL /*&ia32_reg_classes[CLASS_ia32_xmm]*/, get_irn_irg(keep), get_nodes_block(keep), get_irn_arity(keep), &ins[1]);
+               exchange(keep, new_keep);
+       }
+}

diff --git a/ir/be/grgen/simd/simd_opt.h b/ir/be/grgen/simd/simd_opt.h
new file mode 100644 (file)
index 0000000..a632af0
--- /dev/null
+++ b/ir/be/grgen/simd/simd_opt.h
@@ -0,0 +1,16 @@
+/*******************************************************************************************
+* Program:  simd_opt.h
+* Function: Part of the simd optimization. Searches match of complex operation pattern and
+*           inserts the complex operation if possible.
+* Author:   Andreas Schoesser
+* Date:     13.02.2007
+*******************************************************************************************/
+
+
+#ifndef __SIMD_OPT_H__
+#define __SIMD_OPT_H__
+
+/** Performs the searching and rewriting of patterns for the given ir graph */
+void ext_grs_simd_opt(ir_graph *irg);
+
+#endif

diff --git a/ir/be/grgen/simd/simd_opt_t.h b/ir/be/grgen/simd/simd_opt_t.h
new file mode 100644 (file)
index 0000000..ddce1e4
--- /dev/null
+++ b/ir/be/grgen/simd/simd_opt_t.h
@@ -0,0 +1,84 @@
+/*******************************************************************************************
+* Program:  simd_opt_t.h
+* Function: Part of the simd optimization. Searches match of complex operation pattern and
+*           inserts the complex operation if possible.
+* Author:   Andreas Schoesser
+* Date:     05.02.2007
+*******************************************************************************************/
+
+#ifndef __SIMD_OPT_H__
+#define __SIMD_OPT_H__
+
+#include "simd_presets.h"
+#include "simd_opt.h"
+
+#include "pmap.h"
+#include "irdump.h"
+#include "iroptimize.h"
+#include "irgmod.h"
+#include "../ir/be/benode_t.h"
+
+#include "grs/grs.h"
+
+
+#include <time.h>
+#include <grs/action_t.h>
+#include <grs/match_t.h>
+
+typedef struct
+{
+       struct list_head list;
+       ir_node *node;
+} nodes_stack_t;
+
+typedef struct
+{
+       struct list_head *nodes_stack;
+       struct pmap              *pattern_nodes;
+       struct pmap              *memory_preds;
+       ir_graph                 *irg;
+} mem_preds_info_t;
+
+typedef struct
+{
+       int             num_instructions_inserted;
+       int     num_matches;
+       int     num_matched_nodes;
+       int     num_replaced_nodes;
+       int             *rewritten_patterns;
+       clock_t start_time, end_time;
+} statistics_t;
+
+typedef struct
+{
+       struct pmap *node_map_hash;
+       int                     found_dependency;
+} argdep_ana_info_t;
+
+
+
+struct pmap *find_memory_preds(ir_graph *irg, ir_node **match_node_map, int max_node_aiid);
+static void find_mem_preds_pre(ir_node *n, void * env);
+static void find_mem_preds_post(ir_node *n, void * env);
+static ir_node *find_memory_pred(ir_node *n, int *edge_nr, int start_edge);
+static int walk_mem_edge_alias(ir_node *orgn, ir_node *cn, struct pmap *memory_preds, struct pmap *node_map_hash, struct pmap *replaced_ptrs);
+int test_alias_relation(ir_node **node_map, int max_node_aiid, struct pmap *memory_preds, struct pmap *replaced_ptrs);
+struct pmap *generate_nodemap_hash(ir_node **node_map, int max_node_aiid);
+
+static int find_bad_node(ir_node *n);
+void connect_complex_memory(ext_grs_action_t *action, ext_grs_match_t *match, int which, struct pmap *mem_preds);
+void save_complex_operation(ext_grs_action_t *action, ext_grs_match_t *match, int which, struct pmap *vec_operations, int nr);
+void save_keep_nodes(ext_grs_action_t *action, ext_grs_match_t *match, int which, struct pmap *keep_nodes);
+static void rename_complex_operations(struct pmap *vec_operations);
+static void visit_mem_nodes(ir_node *node, mem_preds_info_t *mem_preds_info);
+static void exchange_keep_nodes(struct pmap *keep_nodes);
+int perform_rewrite(ir_graph *irg, struct pmap *vec_operations, struct pmap *keep_nodes, int start, statistics_t *statistics, struct pmap *replaced_ptrs);
+static void view_statistics(statistics_t *statistics);
+int analyze_arguments(ext_grs_action_t *action, ext_grs_match_t *match, int which, ir_graph *irg, struct pmap *memory_preds);
+int search_mem_node(ir_node *n, ir_node *start, ir_graph *irg);
+void compute_match_plans(ir_graph *irg, ext_grs_planer_t *planer, ext_grs_analyzer_t *analyzer);
+static void walk_arg_dep(ir_node *n, void * env);
+int ext_result_costs(ext_grs_match_t *match, int which);
+int single_node_costs(ir_node *n);
+
+#endif

diff --git a/ir/be/grgen/simd/simd_presets.h b/ir/be/grgen/simd/simd_presets.h
new file mode 100644 (file)
index 0000000..3cc6c10
--- /dev/null
+++ b/ir/be/grgen/simd/simd_presets.h
@@ -0,0 +1,85 @@
+/*************************************************************************
+* Program:  presets.h
+* Function: Preset values for simd optimizer
+* Author:   Andreas Schoesser
+* Date:     2006-12-20
+*************************************************************************/
+
+#ifndef _PRESETS_H_
+#define _PRESETS_H_
+
+#include "firm_config.h"
+
+#ifdef HAVE_CONFIG_H
+       #include "config.h"
+#endif
+
+//#ifndef INCLUDE_GENERATED_PATTERNS
+//     #define INCLUDE_GENERATED_PATTERNS 1
+//#endif
+
+// ----------------------------------------------------------------------
+// Possible VisualStudio command lines
+// ----------------------------------------------------------------------
+// --c99 -I C:\DevStudio\Include -f grs-create-pattern C:\diplomarbeit\firmext\grs\simd\testprograms\patterns\vadd_memory\vadd_memory.c
+// --c99 -I C:\DevStudio\Include -f grs-simd-opt C:\diplomarbeit\firmext\grs\simd\testprograms\patterns\vadd_memory\vadd_memory.c
+
+
+// ----------------------------------------------------------------------
+// Presets for RULE generation
+// ----------------------------------------------------------------------
+
+#define MEMORY_ARRAY "memory"
+#define REGISTER_STORE 1
+#define REGISTER_LOAD  0
+#define MEMORY_STORE 1
+#define MEMORY_LOAD  0
+
+#define RESULT_NAME    "Res"
+static char *SIMD_ARGUMENTS[] = { "Arg_0", "Arg_1", "Arg_2", "Arg_3" };
+#define MAX_SIMD_ARGUMENTS 4
+
+#define VECTOR_OP_NAME "Vector_op"
+#define VECTOR_OP_PROJM_NAME "Vector_op_ProjM"
+#define VECTOR_OP_PROJDATA_NAME "Vector_op_ProjData"
+#define COMPLEX_OPERATION_BLOCK_NAME "Vector_op_Block"
+#define VECTOR_RESULT_NAME "Vector_Result"
+
+
+#define EMIT "Emit"
+#define DESTROYS "Destroys"
+#define PRIORITY "Priority"
+#define COST_SAVINGS "CostSavings"
+
+#define VECTOR_BASE_TYPE "VectorBase"
+#define VECTOR_BASE_NAME "NodeVectorBase"
+
+#define MAX_ADDRESS_VARIANTS 3
+
+#define PRIORITY_CLEANUP 10000
+
+
+
+// ----------------------------------------------------------------------
+// DIRECTRORY and FILE presets
+// ----------------------------------------------------------------------
+
+#define GRGEN_LOCATION "C:\\diplomarbeit\\grgen\\"
+#define GENERATION_DEST "C:\\diplomarbeit\\firmext\\grs\\simd\\generated"
+#define GRGEN_GRAPH_FILE "C:\\diplomarbeit\\firmext\\grs\\simd\\C_patterns\\complex_instructions.grg"
+#define RULENAME_FILE "C:\\diplomarbeit\\firmext\\grs\\simd\\generated\\simd_rules.h"
+#define BE_SPEC_FILE "C:\\diplomarbeit\\libfirm\\ir\\be\\ia32\\ia32_simd_spec.pl"
+
+// ----------------------------------------------------------------------
+// Optimization settings
+// ----------------------------------------------------------------------
+
+#define VERBOSE_REWRITE         1
+#define PROMPT_REWRITE          1
+#define PROMPT_NO_PATTERN_FOUND 0
+#define DUMP_SEARCH_PLAN        0
+
+//#define DUMP_EVERYTHING                      1
+
+
+#endif

diff --git a/ir/be/grgen/simd/testprograms/patterns/vadd_memory/Firm.gm b/ir/be/grgen/simd/testprograms/patterns/vadd_memory/Firm.gm
new file mode 100644 (file)
index 0000000..907c4ee
--- /dev/null
+++ b/ir/be/grgen/simd/testprograms/patterns/vadd_memory/Firm.gm
@@ -0,0 +1,441 @@
+/*
+ * Project:     GRS
+ * File name:   Firm.gm
+ * Purpose:     A specification of Firm for use with GrGen
+ * Author:      Rubino Geiss
+ * Mowified by:
+ * Created:     10.9.2003
+ * Copyright:   (c) 2004 Universitaet Karlsruhe
+ * Licence:     GPL
+ */
+
+model Firm;
+
+node class FIRM_node extends Node {
+       generation: int;
+}
+
+edge class FIRM_edge extends Edge {
+       generation: int;
+}
+
+/**********************************************
+ * Modes                                      *
+ **********************************************/
+
+enum ENUM_sort {
+       auxiliary, control_flow, memory, internal_boolean,
+       int_number, float_number, reference, character
+}
+enum ENUM_arithmetic_kind {
+       uninitialized, none, twos_complement, ones_complement,
+       int_BCD, ieee754, float_BCD, max, unknown
+}
+enum ENUM_modecode {
+       irm_BB, irm_X,   irm_F,   irm_D,  irm_E,  irm_Bs,
+       irm_Bu, irm_Hs,  irm_Hu,  irm_Is, irm_Iu, irm_Ls,
+       irm_Lu, irm_C,   irm_P,   irm_b,  irm_M,  irm_T,
+       irm_U,  irm_ANY, irm_BAD, irm_max
+}
+
+node class Mode extends FIRM_node {
+       name            : string;
+       size            : int;
+       sort            : ENUM_sort;
+/*     code            : ENUM_modecode; */
+       sign            : boolean;
+       arithmetic      : ENUM_arithmetic_kind;
+       shift           : int;
+}
+
+
+node class Mode_BB   extends Mode;
+node class Mode_X    extends Mode;
+node class Mode_F    extends Mode;
+node class Mode_D    extends Mode;
+node class Mode_E    extends Mode;
+node class Mode_Bs   extends Mode;
+node class Mode_Bu   extends Mode;
+node class Mode_Hs   extends Mode;
+node class Mode_Hu   extends Mode;
+node class Mode_Is   extends Mode;
+node class Mode_Iu   extends Mode;
+node class Mode_Ls   extends Mode;
+node class Mode_Lu   extends Mode;
+node class Mode_C    extends Mode;
+node class Mode_P    extends Mode;
+node class Mode_b    extends Mode;
+node class Mode_M    extends Mode;
+node class Mode_T    extends Mode;
+node class Mode_U    extends Mode;
+node class Mode_ANY  extends Mode;
+node class Mode_BAD  extends Mode;
+node class Mode_max  extends Mode;
+
+
+
+/**********************************************
+ * Types                                      *
+ **********************************************/
+
+enum ENUM_state       { layout_undefined, layout_fixed }
+
+/************* Type Nodes         *************/
+
+node class Type extends FIRM_node {
+       id    : int;
+       name  : string;
+       state : ENUM_state;
+       size  : int;
+       align : int;
+}
+
+node class Compound extends Type;
+node class Class extends Compound;
+node class Struct extends Compound;
+node class Union extends Compound;
+node class Method extends Type {
+       n_params : int;         // number of calling paramters
+       n_ress   : int;         // number of results
+       variadic : boolean;     // true: additional variadic parameters allowed
+}
+node class Array extends Type {
+       n_dimensions : int;
+}
+node class Enum extends Type;
+node class Pointer extends Type;
+node class Primitive extends Type;
+
+/************* Type Edges         *************/
+
+// Class (Sub) -> Class (Super)
+edge class is_subtype_of extends FIRM_edge
+       connect Class [*] -> Class [*];         // Subclass -> Superclass
+edge class member extends FIRM_edge
+                // Entities may or may not be an Compound member: [0:1]
+       connect Compound [*] -> Entity [0:1];
+edge class parameter extends FIRM_edge
+       connect Method [*] -> Type [*] {
+       position : int;
+}
+edge class result extends FIRM_edge
+       connect Method [*] -> Type [*] {
+       position : int;
+}
+edge class element_type extends FIRM_edge
+       connect Array [1] -> Type [*];
+edge class element_ent extends FIRM_edge
+       connect Array [1] -> Entity [*];
+
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+   TODO XXX const_code_irg is not walked by wif.do_block
+   TODO: Implement upper / lower in firm2grs.c
+   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ */
+edge class lower extends FIRM_edge             // TODO: multidim arrays???
+       connect Array [*] -> IR_node [*] {
+       position : int;
+}
+edge class upper extends FIRM_edge
+       connect Array [*] -> IR_node [*] {
+       position : int;
+}
+
+edge class named_value extends FIRM_edge       // Enum -> Tarval
+       connect Enum [*] -> Tarval [*] {        // TODO: empty Enums [+]???
+       name : string;
+}
+edge class has_type extends FIRM_edge
+       connect Call     [1]   -> Type [*],
+               SymConst [0:1] -> Type [*],
+               Pointer  [1]   -> Type [*];
+
+
+/**********************************************
+ * Tarval                                     *
+ **********************************************/
+
+node class Tarval extends FIRM_node {
+       value : string;         //  is this aprobate
+}
+
+edge class has_mode extends FIRM_edge
+       connect Tarval    [1] -> Mode [*],
+               Pointer   [1] -> Mode [*],
+               Primitive [1] -> Mode [*],
+               Method    [1] -> Mode [*],
+               IR_node   [1] -> Mode [*],
+               Struct    [0:1]->Mode [*],
+                Enum      [1] -> Mode [*];
+edge class has_entity extends FIRM_edge
+       connect SymConst[0:1] -> Entity [*];
+
+
+/**********************************************
+ * Entities                                   *
+ **********************************************/
+
+enum ENUM_allocation   { automatic, parameter, dynamic, static }
+enum ENUM_visibility   { local, global, extern }
+enum ENUM_variability  { uninitialized, initialized, partly_constant, constant }
+enum ENUM_peculiarity  { description, inherited, existent }
+
+/************* Entity Nodes       *************/
+
+node class Entity extends FIRM_node {
+       name        : string;           // the (source) name of the entity
+       ld_name     : string;           // the linker name of the entity
+       offset      : int;
+       allocation  : ENUM_allocation;
+       visibility  : ENUM_visibility;
+       variability : ENUM_variability;
+       peculiarity : ENUM_peculiarity;
+       volatility  : boolean;
+}
+
+/************* Entity Edges       *************/
+
+edge class overwrites extends FIRM_edge
+       connect Entity -> Entity;               // TODO arity ???
+
+edge class init_node extends FIRM_edge;
+//     connect Entity -> Node (of Init);       // TODO arity ???
+
+edge class init_entity extends FIRM_edge;
+//     connect Entity -> Entity (of Init);     // TODO arity ???
+
+edge class graph extends FIRM_edge
+       connect Entity [0:1] -> Method_IRG [*];
+
+edge class type extends FIRM_edge
+       connect Entity [1] -> Type [*];
+
+
+/**********************************************
+ * Method IRG                                 *
+ **********************************************/
+
+/*
+ * Firm IRG the IR graph of a method.
+ * Pointing to Start and End nodes as well as its Entity
+ */
+node class Method_IRG extends FIRM_node {
+       main_method : boolean;  // set, if this method is the main entry point
+}
+
+edge class meth_start extends FIRM_edge
+       connect Method_IRG -> Start;
+
+edge class meth_end extends FIRM_edge
+       connect Method_IRG -> End;
+
+edge class frame_type extends FIRM_edge
+       connect Method_IRG -> Type;
+
+edge class belong_to extends FIRM_edge
+       connect Block -> Method_IRG;
+
+node class IR_node extends FIRM_node {
+       index : int;//quickfix for using vprojs
+}
+
+
+node class Ordinary;
+node class Special;
+node class Arithmetic extends Ordinary;
+node class Controlflow;
+node class Memory;
+
+node class Unary;
+node class Binary;
+node class Trinary;
+node class Nary;
+
+node class Commutative;
+node class Associative;
+
+
+/**********************************************
+ * IR Nodes                                   *
+ **********************************************/
+
+node class Complex extends IR_node;
+node class Block extends IR_node, Special;
+node class Start extends IR_node, Special;
+node class End extends IR_node, Special;
+
+node class Jmp extends IR_node, Controlflow;
+node class Cond extends IR_node, Controlflow, Ordinary;
+node class Return extends IR_node, Controlflow;
+node class Raise extends IR_node, Controlflow;
+
+node class Const extends IR_node, Ordinary {
+       value : string;                 // tarval coded as string
+}
+node class IntConst extends Const {
+  // ATTENTION:
+       // value inherited from Const is set to "<INTCONST>" and may not be used
+       intval : int;                   // tarval coded as string
+}
+
+node class SymConst extends IR_node, Ordinary {
+       kind    : int;
+       ptrinfo : string;
+}
+
+node class Sel extends IR_node;
+node class InstOf extends IR_node;
+node class Call extends IR_node;
+node class Add extends IR_node, Arithmetic, Binary, Commutative;
+node class Sub extends IR_node, Arithmetic, Binary;
+node class Minus extends IR_node, Arithmetic, Unary;
+node class Mul extends IR_node, Arithmetic, Binary, Commutative;
+node class Mulh extends IR_node, Arithmetic, Binary, Commutative;
+node class Quot extends IR_node, Arithmetic, Binary;
+node class DivMod extends IR_node, Arithmetic, Binary;
+node class Div extends IR_node, Arithmetic, Binary;
+node class Mod extends IR_node, Arithmetic, Binary;
+node class Abs extends IR_node, Arithmetic, Unary;
+node class And extends IR_node, Arithmetic, Binary, Commutative;
+node class Or extends IR_node, Arithmetic, Binary, Commutative;
+node class Eor extends IR_node, Arithmetic, Binary, Commutative;
+node class Not extends IR_node, Arithmetic, Unary;
+node class Cmp extends IR_node, Ordinary;
+node class Shl extends IR_node, Arithmetic, Binary;
+node class Shr extends IR_node, Arithmetic, Binary;
+node class Shrs extends IR_node, Arithmetic, Binary;
+node class Rot extends IR_node, Arithmetic, Binary;
+node class Conv extends IR_node, Ordinary;
+node class Cast extends IR_node; // TODO classify
+node class Phi extends IR_node, Ordinary;
+node class Mux extends IR_node, Trinary; // TODO classify
+
+node class MemNode extends IR_node, Memory {
+       volatility  : boolean;
+}
+
+node class Load extends MemNode;
+node class Store extends MemNode;
+
+enum ENUM_alloc_where { stack_alloc, heap_alloc }
+
+node class Alloc extends IR_node, Memory {
+       where : ENUM_alloc_where;
+}
+node class Free extends IR_node, Memory;
+node class Sync extends IR_node, Memory {
+       arity : int;
+}
+
+node class SyncArity2 extends Sync;// A sync with arity 2, that has a wrong arity attribute
+node class IgnoreCF;   // it is not important to which block this node is connected
+
+node class Proj extends IR_node, Ordinary {
+       proj : int;
+}
+
+// TODO classify the following IR_nodes
+node class Tuple extends IR_node;
+node class Id extends IR_node;
+node class Bad extends IR_node;
+node class NoMem extends IR_node;
+node class Confirm extends IR_node;
+node class Unknown extends IR_node;
+node class Filter extends IR_node;
+node class Break extends IR_node, Controlflow;
+node class CallBegin extends IR_node;
+node class EndReg extends IR_node;
+node class EndExcept extends IR_node, Controlflow;
+
+/**********************************************
+ * IR Intrinsic Nodes                         *
+ **********************************************/
+node class Intrinsic extends IR_node, Ordinary
+{
+       type : string;
+}
+
+node class IntrinsicGP  extends Intrinsic;     // a intrinsic with gp registers
+node class IntrinsicGP3  extends Intrinsic;    // a intrinsic with 3 gp registers
+node class IntrinsicFP  extends Intrinsic;     // a intrinsic with fp registers
+node class IntrinsicMMX extends Intrinsic;     // a intrinsic with mmx registers
+node class IntrinsicSSE extends Intrinsic;     // a intrinsic with sse registers
+
+node class Intrinsic_sse_sse_sse extends Intrinsic;    // a intrinsic
+node class Intrinsic_sse_sse extends Intrinsic;                // a intrinsic
+node class Intrinsic_sse_addr_sse extends Intrinsic;   // a intrinsic
+node class Intrinsic_addr_sse_store extends Intrinsic; // a intrinsic
+node class Intrinsic_reg_sse_sse extends Intrinsic;    // a intrinsic
+node class Intrinsic_sse_reg_sse extends Intrinsic;    // a intrinsic
+node class Intrinsic_sse_addr_store extends Intrinsic; // a intrinsic
+node class Intrinsic_addr_addr_store extends Intrinsic;        // a intrinsic
+node class Intrinsic_addr_sse extends Intrinsic;       // a intrinsic
+node class Intrinsic_addr_addr_sse extends Intrinsic;  // a intrinsic
+
+node class max extends IntrinsicGP;    // a max instruction
+node class min extends IntrinsicGP;    // a min instruction
+
+node class CMOV extends IntrinsicGP;   // a conditional move instruction
+
+node class CCopy extends IntrinsicGP;  // a conditional copy instruction
+                                       // CCopy(val0:df, val1:df, cond:bool):df
+
+
+//select parts of a register (e.g. 32 bit of a 128 bit register)
+node class VProj extends IR_node, Ordinary{
+       proj : int;
+}
+
+node class Match;
+node class IntrinsicMatch extends Match{
+       name : string;
+}
+
+
+/************* IR Edges         *************/
+
+edge class flow extends FIRM_edge
+       connect IR_node [*] -> IR_node [*] {
+       position : int;
+}
+
+edge class df extends flow;            // IR_node -> IR_node, data flow
+edge class mem extends df;             // IR_node -> IR_node, memory
+edge class tuple extends df;           // Edges of Mode Tuple
+edge class cf extends flow             // control flow
+       connect IR_node [1] -> Block [*],
+                // We cannot distinguish ProjI etc from ProjXi: therefor 0
+                // ProjX form Start has 2 successors
+               Block   [*] -> Proj  [0:2];
+
+
+/**********************************************
+ * Extensions                                 *
+ **********************************************/
+
+node class Vector extends IR_node;
+
+node class V2 extends Vector;
+node class V4 extends Vector;
+
+node class pi;
+
+node class V2pi_1 extends V2, pi;
+node class V2pi_2 extends V2, pi;
+
+node class V4pi_1 extends V4, pi;
+node class V4pi_2 extends V4, pi;
+node class V4pi_3 extends V4, pi;
+node class V4pi_4 extends V4, pi;
+
+node class V2Load extends V2;
+node class V2Store extends V2;
+
+node class V2Sub extends V2;
+
+edge class match {
+       nr : int;
+}
+
+node class StartBlock;

diff --git a/ir/be/grgen/simd/testprograms/patterns/vadd_memory/vadd_host.c b/ir/be/grgen/simd/testprograms/patterns/vadd_memory/vadd_host.c
new file mode 100644 (file)
index 0000000..249b718
--- /dev/null
+++ b/ir/be/grgen/simd/testprograms/patterns/vadd_memory/vadd_host.c
@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <malloc.h>
+
+//int a[4], b[4], c[4];
+//int *a, *b, *c;
+
+void vadd_host(int *a, int *b, int *c)
+{
+       //int *a = (int *) malloc(8), *b = (int *) malloc(8), *c = (int *) malloc(8);
+       //int a[2], b[2], c[2];
+
+
+       c[0] = a[0] + b[0];
+       c[1] = a[0] + b[1];
+
+       printf("%d %d", c[0], c[1]);
+}
+
+/*void test_cond(int n, int *a, int *b)
+{
+       if(n > 10)
+       {
+               a[0] = b[1];
+               a[1] = b[0];
+       }
+       else
+       {
+               a[1] = b[1];
+               a[0] = b[0];
+       }
+} */

diff --git a/ir/be/grgen/simd/testprograms/patterns/vadd_memory/vadd_memory.c b/ir/be/grgen/simd/testprograms/patterns/vadd_memory/vadd_memory.c
new file mode 100644 (file)
index 0000000..48f3495
--- /dev/null
+++ b/ir/be/grgen/simd/testprograms/patterns/vadd_memory/vadd_memory.c
@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include "define_operation.h"
+
+typedef int sse_register;
+
+union input_register_set
+{
+       sse_register hardware_reg_1;
+       sse_register hardware_reg_2;
+       sse_register hardware_reg_3;
+} input_register_set;
+
+union output_register_set
+{
+       sse_register hardware_reg_1;
+       sse_register hardware_reg_2;
+       sse_register hardware_reg_3;
+} output_register_set;
+
+int memory_array[100];
+
+typedef int sse_32_2;
+
+
+void vadd_memory(void)
+{
+       // Only Register
+       /*sse_32_2 *param0 = SSEArg_0(input_register_set);
+       sse_32_2 *param1 = SSEArg_1(input_register_set);
+       sse_32_2 *result = SSEArg_Res(output_register_set); */
+
+       // Only Memory
+       /*sse_32_2 *param0 = SSEArg_0(memory_array);
+       sse_32_2 *param1 = SSEArg_1(memory_array);
+       sse_32_2 *result = SSEArg_Res(memory_array); */
+
+       // Mixed
+       sse_32_2 *param0 = Arg_0(memory_array);
+       sse_32_2 *param1 = Arg_1(memory_array);
+       sse_32_2 *result = Res(&output_register_set);
+
+       result[0] = param0[0] + param1[0];
+       result[1] = param0[0] + param1[1];
+
+/*     int a0, a1, b0, b1, r0, r1;
+
+       a0 = param0[0];
+       a1 = param0[1];
+       b0 = param1[0];
+       b1 = param1[1];
+
+       if(a0 > b1)
+       {
+               r0 = a0 + a0 + b0; //result[0] = param0[0] + param0[0] + param1[0];
+               r1 = a1 + a0 + b1; //result[1] = param0[1] + param0[0] + param1[1];
+       }
+       else
+       {
+               r0 = a0; //result[0] = param0[0];
+               r1 = a1; //result[1] = param0[1];
+       }
+
+       result[0] = r0;
+       result[1] = r1; */
+}
+
+ void vstore(void)
+{
+       sse_32_2 *param = Arg_0(&input_register_set);
+       sse_32_2 *result = Arg_1(memory_array);
+
+       result[0] = param[0];
+       result[1] = param[1];
+}

diff --git a/ir/be/grgen/uf_mpq.h b/ir/be/grgen/uf_mpq.h
new file mode 100644 (file)
index 0000000..d2a0208
--- /dev/null
+++ b/ir/be/grgen/uf_mpq.h
@@ -0,0 +1,382 @@
+#ifndef _EXT_GRS_UF_MPQ_H_
+#define _EXT_GRS_UF_MPQ_H_
+
+/*
+ * Project:     libFIRM/extension module/GRS-matcher
+ * File name:   ext/grs/uf_mpq.h
+ * Purpose:     provides a union find structure (uf) (disjoint sets)
+ *              and a meldable priority queue implementation (mpq)
+ *              for pattern edges (note: in case of the uf edges are
+ *              represented by their edge ids. This is because a
+ *              disjoint integer set implementation is used.)
+ *                             @note The uf-concept used in this impl allows
+ *                                   only elems greater than zero, but there are
+ *                                   elems greater or EQUAL zero supported!
+ * Author:      Veit Batz
+ * Created:            7. June 2005
+ * CVS-ID:      $Id$
+ * Copyright:   (c) 2005 Universität Karlsruhe
+ * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ */
+
+#include <stdlib.h>
+
+
+#include "array.h"
+#include "common_t.h"
+#include "action_t.h"
+
+
+
+
+#undef MAX
+#define MAX(a,b) ( (a)>=(b) ? (a) : (b) )
+
+
+
+typedef double uf_value_t;
+
+static int *uf_parent;
+static uf_value_t *uf_value;
+static uf_value_t *uf_update;
+
+static int uf_current_size = 1000;
+static int uf_max_size = 0;
+static int uf_already_used = 0;
+
+/** initialize the union find structure */
+void ext_grs_uf_init(int max_elem) {
+
+       int max_size = max_elem + 1;
+
+       if (uf_already_used == 0) {
+               uf_current_size = MAX(max_size, 1000);
+               uf_parent = NEW_ARR_F(int, uf_current_size);
+               uf_value = NEW_ARR_F(uf_value_t, uf_current_size);
+               uf_update = NEW_ARR_F(uf_value_t, uf_current_size);
+               uf_already_used = 1;
+       }
+
+       if (max_size > uf_current_size) {
+               uf_current_size = max_size;
+               ARR_RESIZE(*uf_parent, uf_parent, uf_current_size);
+               ARR_RESIZE(*uf_value, uf_value, uf_current_size);
+               ARR_RESIZE(*uf_update, uf_update, uf_current_size);
+       }
+
+       memset(uf_parent, 0, max_size * sizeof(*uf_parent));
+       memset(uf_value, 0, max_size * sizeof(*uf_value));
+       memset(uf_update, 0, max_size * sizeof(*uf_update));
+
+       uf_max_size = max_size;
+}
+
+/** find the value of the given elem */
+uf_value_t ext_grs_uf_find_value(int elem) {
+
+       int old_parent = uf_parent[elem];
+       int new_root;
+       uf_value_t eff_parent_update = 0;
+       uf_value_t new_update = 0;
+
+       /* check wether the given elem is in range */
+       assert (elem < uf_max_size && "union find elem out of bounds");
+
+       /* if elem is a root... */
+       if (old_parent <= 0) {
+               /* ...simply return the elems effective value */
+               return uf_value[elem] + uf_update[elem];
+       }
+
+       /* if the old parent is a root... */
+       if (uf_parent[old_parent] <= 0) {
+               /* ...simply return the elems effective value */
+               return uf_value[elem] + uf_update[elem] + uf_update[old_parent];
+       }
+
+       /* otherwise get effective parental update recursively */
+       eff_parent_update = ext_grs_uf_find_value(old_parent) - uf_value[old_parent];
+
+       /* do path compression: */
+       /* let the old parents parent be the new parent, which must be the
+        * current root (by returning from recursion this has been set up by
+        * the recusrsive ascend to the root) */
+       new_root = uf_parent[old_parent];
+       uf_parent[elem] = new_root;
+
+       /* adapt the update vaule */
+       new_update = uf_update[elem] + eff_parent_update - uf_update[new_root];
+       uf_update[elem] = new_update;
+
+       /* return the effective value of the elem */
+       return uf_value[elem] + new_update;
+}
+
+/** find the root of the set <code>elem</code> belongs to */
+int ext_grs_uf_find(int elem) {
+
+       /* check wether the given elem is in range */
+       assert (elem < uf_max_size && "union find elem out of bounds");
+
+       /* if elem is a root... */
+       if (uf_parent[elem] <= 0) {
+               /* ...simply return the elems effective value */
+               return elem;
+       }
+
+       /* otherwise call find_value() for the elem (which performs path
+        * compression for the elem) */
+       ext_grs_uf_find_value(elem);
+
+       /* after path compression the parrent of elem has to be a root */
+       assert(uf_parent[uf_parent[elem]] <= 0 && "after path compression the parent should be a root");
+       return uf_parent[elem];
+}
+
+/** unite the sets given by the roots <code>root1</code> and <code>root2</code> */
+int ext_grs_uf_unite(int root1, int root2) {
+
+       /* check wether the given elements are roots */
+       assert (uf_parent[root1] <= 0 && uf_parent[root2] <= 0 && "not a root element");
+
+       /* check wether the given elem is in range */
+       assert (root1 < uf_max_size && root2 < uf_max_size &&
+               "union find elem out of bounds");
+
+       /* the less deeper set is connected to the more deeper set */
+       if (uf_parent[root1] < uf_parent[root2]) {
+               uf_parent[root2] = root1;
+               uf_update[root2] -= uf_update[root1];
+               return root1;
+       }
+
+       uf_parent[root1] = root2;
+       uf_update[root1] -= uf_update[root2];
+       if (uf_parent[root1] == uf_parent[root2])
+               uf_parent[root2]--;
+       return root2;
+}
+
+
+
+
+
+
+/* Folgende Funktion FALSCH????? */
+
+
+/** add the given value <code>a</code> to the values of all
+ *  elements of the set given by <code>root</code> */
+void ext_grs_uf_change_value(int root, uf_value_t a) {
+
+       /* check wether the given elem is in range */
+       assert (root < uf_max_size && "union find elem out of bounds");
+
+       assert (uf_parent[root] <= 0 && "not a root element");
+       uf_update[root] += a;
+}
+
+
+
+
+
+
+
+
+
+
+/* the meldable priority queue implementation */
+
+
+
+
+/**
+ * iterate over a list starting with <code>pos</code> up to the lists end
+ * */
+#define list_for_each_from(pos, head) \
+       for ( ; pos != (head); pos = pos->next )
+
+#define GET_ACTUAL_EDGE_COST(e) \
+       ((e)->cost - ext_grs_uf_find_value((e)->arg->aiid + 1))
+
+
+
+/** a priority queue of edges */
+typedef lc_list_t ext_grs_mpq_t;
+
+
+
+
+
+static struct obstack obst;
+static int obst_already_initlzd = 0;
+
+
+/** initialize the meldable priority queue inplementation */
+void ext_grs_mpq_init(void)
+{
+       if (! obst_already_initlzd) {
+               obstack_init(&obst);
+       }
+       else {
+               obstack_free(&obst, NULL);
+               obstack_init(&obst);
+       }
+       obst_already_initlzd = 1;
+}
+
+/** create a new empty priority queue */
+ext_grs_mpq_t *ext_grs_mpq_create(void)
+{
+       ext_grs_mpq_t *mpq = obstack_alloc(&obst, sizeof(*mpq));
+
+       assert(obst_already_initlzd = 1 && "mpq structure not initialized yet");
+
+
+       LC_INIT_LIST_HEAD(mpq);
+       return mpq;
+}
+
+/** insert the given elem in the given priority queue */
+void ext_grs_mpq_insert(ext_grs_mpq_t *pq, ext_grs_edge_t *e)
+{
+       lc_list_t *pos;
+       ext_grs_edge_t *edge;
+
+       assert (pq != NULL && "NULL pointer is not a valid priority queue");
+
+       if (lc_list_empty(pq)) {
+               lc_list_add(& e->mpq_list, pq);
+               return;
+       }
+
+       /* go through pq untill the appropriate position is reached */
+       lc_list_for_each(pos, pq) {
+               edge = lc_list_entry(pos, ext_grs_edge_t, mpq_list);
+               if (GET_ACTUAL_EDGE_COST(e) <= GET_ACTUAL_EDGE_COST(edge)) {
+                       lc_list_add_tail( & e->mpq_list, & edge->mpq_list );
+                       return;
+               }
+       }
+
+       lc_list_add( & e->mpq_list, & edge->mpq_list );
+
+}
+
+/** get the an item with a minimal prio or NULL if <code>pq</code> is empty */
+ext_grs_edge_t *ext_grs_mpq_find_min(ext_grs_mpq_t *pq)
+{
+       assert (pq != NULL && "NULL pointer is not a valid priority queue");
+
+       /* return NULL if pq is empty */
+       if (lc_list_empty(pq)) return NULL;
+
+       /* return first item otherwise */
+       return lc_list_entry(pq->next, ext_grs_edge_t, mpq_list);
+}
+
+/** Remove and return an item with a minimal prio, if <code>pq</code> is empty
+ *  return NULL.
+ *  @note      The member <code>list</code> of the returned item
+ *                     is in an undefined state. */
+ext_grs_edge_t *ext_grs_mpq_delete_min(ext_grs_mpq_t *pq)
+{
+       ext_grs_edge_t *first_edge;
+
+       assert (pq != NULL && "NULL pointer is not a vaild priority queue");
+
+       /* return NULL if pq is empty */
+       if (lc_list_empty(pq)) return NULL;
+
+       /* otherwise remove and return the first item */
+       first_edge = lc_list_entry(pq->next, ext_grs_edge_t, mpq_list);
+       lc_list_del(& first_edge->mpq_list);
+       return first_edge;
+}
+
+void ext_grs_mpq_dump(ext_grs_mpq_t *pq);
+
+/** Meld two item disjoint priority queues <code>pq1</code> and <code>pq2</code>.
+ *  ATTENTION: The given priority queues will be <b>destroyed!</b> */
+ext_grs_mpq_t *ext_grs_mpq_meld(ext_grs_mpq_t *pq1, ext_grs_mpq_t *pq2)
+{
+       lc_list_t *pos1, *pos2, *n;
+       ext_grs_edge_t *e1, *e2;
+       int last = 1; /* tells wether that pq1 has been iteratied till the end and never breaked */
+
+       assert (pq1 != NULL && pq2 != NULL && "NULL pointer is not a vaild priority queue");
+       assert (pq1 != pq2 && "cannot meld an pq with itself");
+
+#ifdef EXT_GRS_DEBUG
+       printf("pq1:\n");
+       ext_grs_mpq_dump(pq1);
+       printf("pq2:\n");
+       ext_grs_mpq_dump(pq2);
+#endif
+
+
+       /* if pq1 is empty return pq2 */
+       if (lc_list_empty(pq1)) return pq2;
+
+       /* insert the items of pq2 into pq1 (at appropriate positions) */
+       pos1 = pq1->next; /* start walking pq1 from beginning */
+       lc_list_for_each_safe (pos2, n, pq2) {
+               e2 = lc_list_entry(pos2, ext_grs_edge_t, mpq_list);
+               list_for_each_from (pos1, pq1) {
+                       e1 = lc_list_entry(pos1, ext_grs_edge_t, mpq_list);
+                       if (GET_ACTUAL_EDGE_COST(e2) <= GET_ACTUAL_EDGE_COST(e1)) {
+                               last = 0;
+                               break;
+                       }
+               }
+
+               if (last) {
+                       /* pq1 has been iterated till the end */
+                       /* insert item2 before the curent position in pq1 */
+                       lc_list_move(& e2->mpq_list, & e1->mpq_list);
+                       e1 = e2;
+               }
+               else {
+                       /* insert item2 before the curent position in pq1 */
+                       lc_list_move_tail(& e2->mpq_list, & e1->mpq_list);
+                       /* continue in pq1 with the current item */
+                       pos1 = & e1->mpq_list;
+                       /* maybe next time the end of pq1 is reached */
+                       last = 1;
+               }
+       }
+
+#ifdef EXT_GRS_DEBUG
+       printf("Result queue:\n");
+       ext_grs_mpq_dump(pq1);
+       printf("\n");
+#endif
+
+       return pq1;
+}
+
+
+/** Remove the given item from the given priority queue.
+ *  @note The list of the deleted item is in an undifind state afterwards. */
+void ext_grs_mpq_delete(ext_grs_edge_t *e)
+{
+       /* remove the item from its priority queue */
+       lc_list_del(& e->mpq_list);
+}
+
+
+void ext_grs_mpq_dump(ext_grs_mpq_t *pq) {
+       lc_list_t *pos;
+
+       printf("{\n");
+       lc_list_for_each(pos, pq) {
+               ext_grs_edge_t *edge = lc_list_entry(pos, ext_grs_edge_t, mpq_list);
+               printf("\t(name, cost, actual cost) =  (%s, %lf, %lf)\n",
+                       edge->name, edge->cost, GET_ACTUAL_EDGE_COST(edge));
+       }
+       printf("}\n");
+}
+
+
+
+#endif /*_UF_MPQ_H_*/