modelverse/addis/PM_to_SCCD.mvc

include "primitives.alh"
include "modelling.alh"
include "object_operations.alh"
include "compiler.alh"


Composite schedule {
    {Contains} Failure failure {}
    {Contains} Success success {}
    {Contains} Atomic create_orchestrator {
        LHS {
            Pre_SCCD/Diagram pre_diagram_0 {
                label = "0"
            }
        }
        RHS {
            Post_SCCD/Diagram post_diagram_0 {
                label = "0"
            }
            Post_SCCD/Class post_class_1 {
                label = "1"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Orchestrator"!
                    $
                value_constructor_body = $
                    Element function value(model : Element, name : String, mapping : Element):
                        Element result
                        String code
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function constructor_body (attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tdict_add(attributes, \"id\",'")
                        code = string_join(code, name)
                        code = string_join(code, "')\n")
                        code = string_join(code, "\tdict_add(attributes, \"queue\", list_create())\n")
                        code = string_join(code, "\tdict_add(attributes, \"finish\", dict_create())\n")
                        code = string_join(code, "\tdict_add(attributes, \"token\", dict_create())\n")
                        code = string_join(code, "\tdict_add(attributes, \"data\", dict_create())\n")
                        code = string_join(code, "\tdict_add(attributes, \"decision_consumes\", dict_create())\n")
                        code = string_join(code, "\tdict_add(attributes, \"assn_names\", dict_create())\n")
                        code = string_join(code, "\tlog(\"INSIDE ORCHESTRATOR CLASS CONSTRUCTOR\")\n")
                        code = string_join(code, "\treturn!")
                        result = compile_code(code)
                        log(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_default = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/diagram_classes (post_diagram_0, post_class_1) {
                label = "2"
            }
            Post_SCCD/CompositeState post_cs_3 {
                label = "3"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Root"!
                    $
            }
            Post_SCCD/behaviour (post_class_1, post_cs_3) {
                label = "4"
            }
            Post_SCCD/BasicState post_bs_5 {
                label = "5"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Init"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/composite_children (post_cs_3, post_bs_5) {
                label = "6"
            }
            Post_SCCD/ParallelState post_ps_7 {
                label = "7"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Running"!
                    $
                value_onEntryScript = $
                     Element function value(model : Element, name : String, mapping : Element):
                        Element result
                        String code
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function constructor_body (attributes : Element):\n")
                        code = string_join(code, "\tlog(\"INSIDE PARALLEL RUNNING STATE\")\n")
                        code = string_join(code, "\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/transition (post_bs_5, post_ps_7) {
                label = "8"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
            }
            Post_SCCD/CompositeState post_cs_9 {
                label = "9"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Queue_spawn"!
                    $
            }
            Post_SCCD/CompositeState post_cs_10 {
                label = "10"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Spawning"!
                    $
            }
            Post_SCCD/parallel_children (post_ps_7, post_cs_9) {
                label = "11"
            }
            Post_SCCD/parallel_children (post_ps_7, post_cs_10) {
                label = "12"
            }
            Post_SCCD/composite_children (post_cs_3, post_ps_7) {
                label = "13"
            }
            Post_SCCD/BasicState post_bs_14 {
                label = "14"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Waiting"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/transition post_trans_15(post_bs_14, post_bs_14) {
                label = "15"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "spawn_exec"!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tlist_append(attributes[\"queue\"], parameters[0])\n")
                        code = string_join(code, "\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/FormalParameter post_fp_16 {
                label = "16"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "exec_name"!
                    $
            }
            Post_SCCD/transition_parameters (post_trans_15, post_fp_16) {
                label = "17"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                    $
            }
            Post_SCCD/composite_children (post_cs_9, post_bs_14) {
                label = "18"
            }
            Post_SCCD/BasicState post_bs_19 {
                label = "19"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Waiting"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/BasicState post_bs_20 {
                label = "20"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Creating"!
                    $
            }
            Post_SCCD/composite_children (post_cs_10, post_bs_19) {
                label = "21"
            }
            Post_SCCD/composite_children (post_cs_10, post_bs_20) {
                label = "22"
            }
            Post_SCCD/transition post_trans_23 (post_bs_19, post_bs_20) {
                label = "23"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\treturn integer_gt(list_len(attributes[\"queue\"]), 0)!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/Raise post_re_24 {
                label = "24"
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "create_instance"!
                    $
                value_scope = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "cd"!
                    $
                value_parameter = $
                    Element function raise(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Element function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tElement param\n")
                        code = string_join(code, "\tparam = list_create()\n")
                        code = string_join(code, "\tlist_append(param, 'association_name')\n")
                        code = string_join(code, "\tlist_append(param, list_read(attributes[\"queue\"], 0))\n")
                        code = string_join(code, "\tlist_append(param, read_root())\n")
                        code = string_join(code, "\treturn param!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                $
            }
            Post_SCCD/ActualParameter post_ap_25 {
                label = "25"
                value_exp = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "'children'"!
                    $
            }
            Post_SCCD/ActualParameter post_ap_26 {
                label = "26"
                value_exp = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "'Activity'"!
                    $
            }
            Post_SCCD/raise_parameters (post_re_24, post_ap_25) {
                label = "27"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                    $
            }
            Post_SCCD/raise_parameters (post_re_24, post_ap_26) {
                label = "28"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 1!
                    $
            }
            Post_SCCD/transition_raises (post_trans_23, post_re_24) {
                label = "29"
            }
            Post_SCCD/transition post_trans_30 (post_bs_20, post_bs_19) {
                label = "30"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "instance_created"!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tString exec_name\n")
                        code = string_join(code, "\texec_name = list_pop(attributes['queue'], 0)\n")
                        code = string_join(code, "\tdict_overwrite(attributes['assn_names'], exec_name, parameters[0])\n")
                        code = string_join(code, "\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/Raise post_re_36 {
                label = "36"
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "set_id"!
                    $
                value_scope = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "narrow"!
                    $
                value_target = $
                    String function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "String function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tlog(\"TARGET\")\n")
                        code = string_join(code, "\tlog(parameters[0])\n")
                        code = string_join(code, "\treturn parameters[0]!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_parameter = $
                    Element function raise(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Element function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tElement param\n")
                        code = string_join(code, "\tparam = list_create()\n")
                        code = string_join(code, "\tlist_append(param, parameters[0])\n")
                        code = string_join(code, "\tlist_append(param, attributes[\"id\"])\n")
                        code = string_join(code, "\treturn param!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                $
            }
            Post_SCCD/transition_raises (post_trans_30, post_re_36) {
                label = "37"
            }
            Post_SCCD/FormalParameter post_fp_31 {
                label = "31"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "association_name"!
                    $
            }
            Post_SCCD/transition_parameters (post_trans_30, post_fp_31) {
                label = "32"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                    $
            }
            Post_SCCD/BasicState post_bs_33 {
                label = "33"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "End"!
                    $
            }
            Post_SCCD/composite_children (post_cs_3, post_bs_33) {
                label = "34"
            }
            Post_SCCD/transition post_trans_35 (post_ps_7, post_bs_33) {
                label = "35"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "process_done"!
                    $
            }
        }    
    }

    {Contains} ForAll create_class_association {
        LHS {
            Pre_SCCD/Class {
                label = "0"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value != "Orchestrator")!
                    $
            }
            Pre_SCCD/Class {
                label = "1"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Orchestrator")!
                    $
            }
        }
        RHS {
            Post_SCCD/Class post_exec_class_0{
                label = "0"
            }
            Post_SCCD/Class post_orchestrator_class_1{
                label = "1"
            }
            Post_SCCD/association (post_orchestrator_class_1, post_exec_class_0){
                label = "3"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "children"!
                    $
            }
        }
    }

    {Contains} Atomic ModifyFork2Fork {
        LHS {
            Pre_PM/Fork pre_f0{
                label = "0"
            }
            Pre_PM/Fork pre_f1{
                label = "1"
            }
            Pre_PM/Activity pre_a1{
                label = "2"
            }
            Pre_PM/Next (pre_f0, pre_f1) {
                label = "3"
            }
            Pre_PM/Next (pre_f1, pre_a1) {
                label = "4"
            }
        }
        RHS {
            Post_PM/Fork post_f0{
                label = "0"
            }
            Post_PM/Fork post_f1{
                label = "1"
            }
            Post_PM/Activity post_a1{
                label = "2"
            }
            Post_PM/Next (post_f0, post_f1){
                label = "3"
            }
            Post_PM/Next (post_f0, post_a1) {
                label = "5"
                value_id = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
            }
        }
    }

    {Contains} ForAll RemoveFork2Fork {
        LHS {
            Pre_PM/Fork f0{
                label = "0"
            }
            Pre_PM/Fork f1{
                label = "1"
            }
            Pre_PM/Next (f0, f1) {
                label = "3"
            }
        }
        RHS {
            Post_PM/Fork f{
                label = "0"
            }
        }
    }

    {Contains} ForAll initialize {
        LHS {
            Pre_PM/Activity {
                label = "0"
            }
            Pre_SCCD/BasicState {
                label = "1"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Init")!
                    $
            }
            constraint = $
                Boolean function constraint (model : Element, mapping : Element):
                    Element children 
                    String parent
                    Element class_beh 
                    String class

                    children = allIncomingAssociationInstances(model, mapping["1"], "SCCD/composite_children")
                    if list_len(children) >0:
                        parent = readAssociationSource(model, set_pop(children))
                        class_beh = allIncomingAssociationInstances(model, parent, "SCCD/behaviour")
                        if list_len(class_beh) >0:
                            class = readAssociationSource(model, set_pop(class_beh))
                            if (value_eq(read_attribute(model, class, "name"), "Orchestrator")):
                                return True!
                            else:
                                return False!
                        else:
                            return False!
                    else:
                        return False!
                $
        }
        RHS {
            Post_PM/Activity post_activity_0{
                label = "0"
            }
            Post_SCCD/BasicState post_init_bs_1{
                label = "1"
                value_onEntryScript = $
                    String function value(model : Element, name : String, mapping : Element):
                        String type
                        String joined_str
                        Element outgoing_assns
                        String edge
                        String activity
                        String onEntryScript

                        type = read_type(model, mapping["0"])
                        onEntryScript = read_attribute(model, mapping["1"], "onEntryScript")
                        if value_eq(has_value(onEntryScript),False):
                            onEntryScript = ""
                        if (type == "PM/Start"):
                            joined_str = string_join("\tdict_overwrite(attributes['token'],'", read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str,"',True)\n")
                            return string_join(onEntryScript, joined_str)!
                        elif (type == "PM/Decision"):
                            joined_str = string_join("\tdict_overwrite(attributes['token'],'", read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str, "',False)\n")
                            joined_str = string_join(joined_str, "\tdict_overwrite(attributes['decision_consumes'],'")
                            joined_str = string_join(joined_str, read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str, "','')\n")
                            return string_join(onEntryScript, joined_str)!
                        elif bool_or(type == "PM/Join", type == "PM/Finish"):
                            joined_str = string_join("\tdict_overwrite(attributes['token'],'", read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str, "', False)\n")
                            return string_join(onEntryScript, joined_str)!
                        elif (type == "PM/Exec"):
                            joined_str = string_join("\tdict_overwrite(attributes['token'],'", read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str, "', False)\n")
                            joined_str = string_join(joined_str, "\tdict_overwrite(attributes['finish'],'")
                            joined_str = string_join(joined_str, read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str, "',False)\n")
                            return string_join(onEntryScript, joined_str)!
                        elif (type == "PM/Fork"):
                            joined_str = string_join("\tdict_overwrite(attributes['token'],'", read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str, "', False)\n")
                            joined_str = string_join(joined_str, "\tdict_overwrite(attributes['finish'],'")
                            joined_str = string_join(joined_str, read_attribute(model, mapping["0"], "id"))
                            joined_str = string_join(joined_str, "', dict_create())\n")
                            outgoing_assns = allOutgoingAssociationInstances(model, mapping["0"], "PM/Next")
                            while (read_nr_out(outgoing_assns) > 0):
                                edge = set_pop(outgoing_assns)
                                activity = readAssociationDestination(model, edge)
                                joined_str = string_join(joined_str,"\tdict_overwrite(attributes['finish']['")
                                joined_str = string_join(joined_str, read_attribute(model, mapping["0"], "id"))
                                joined_str = string_join(joined_str, "'],'")
                                joined_str = string_join(joined_str, read_attribute(model, activity, "id")) 
                                joined_str = string_join(joined_str, "', False)\n")
                            return string_join(onEntryScript, joined_str)!
                    $
            }
        }
    }

    {Contains} Atomic compile_init_script {
        LHS {
            Pre_SCCD/BasicState pre_init_0 {
                label = "0"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Init")!
                    $
            }
            constraint = $
                Boolean function constraint (model : Element, mapping : Element):
                    Element children
                    String parent
                    Element class_beh
                    String class

                    children = allIncomingAssociationInstances(model, mapping["0"], "SCCD/composite_children")
                    if list_len(children) >0:
                        parent = readAssociationSource(model, set_pop(children))
                        class_beh = allIncomingAssociationInstances(model, parent, "SCCD/behaviour")
                        if list_len(class_beh) >0:
                            class = readAssociationSource(model, set_pop(class_beh))
                            if (value_eq(read_attribute(model, class, "name"), "Orchestrator")):
                                return True!
                            else:
                                return False!
                        else:
                            return False!
                    else:
                        return False!
                $
        }
        RHS {
            Post_SCCD/BasicState post_init_0{
                label = "0"
                value_onEntryScript = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        String script
                        script = read_attribute(model, mapping["0"], "onEntryScript")
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function onEntryScript (attributes : Element):\n")
                        code = string_join(code, "\tlog(\"INSIDE INIT STATE\")\n")
                        code = string_join(code, script)
                        code = string_join(code, "\tlog(\"FINISHED EXECUTING INIT ONENTRY\")\n")
                        code = string_join(code, "\treturn!")
                        log(code)
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
        }
    }

    {Contains} ForAll map_exec {
        LHS {
            Pre_PM/Activity pre_exec_0 {
                label = "0"
            }
            Pre_PM/Exec pre_exec_1 {
                label = "1"
            }
            Pre_PM/Next pre_next_2 (pre_exec_0, pre_exec_1) {
                label = "2"
            }
            Pre_SCCD/ParallelState pre_ps_3 {
                label = "3"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Running")!
                    $
            }
            constraint = $
                Boolean function constraint (model : Element, mapping : Element):
                    Element children 
                    String parent
                    Element class_beh 
                    String class

                    children = allIncomingAssociationInstances(model, mapping["3"], "SCCD/composite_children")
                    if list_len(children) >0:
                        parent = readAssociationSource(model, set_pop(children))
                        class_beh = allIncomingAssociationInstances(model, parent, "SCCD/behaviour")
                        if list_len(class_beh) >0:
                            class = readAssociationSource(model, set_pop(class_beh))
                            if (value_eq(read_attribute(model, class, "name"), "Orchestrator")):
                                return True!
                            else:
                                return False!
                        else:
                            return False!
                    else:
                        return False!
                $
        }
        RHS {
            Post_PM/Activity post_exec_0 {
                label = "0"
            }
            Post_PM/Exec post_exec_1 {
                label = "1"
            }
            Post_PM/Next post_flow_2 (post_exec_0, post_exec_1) {
                label = "2"
            }
            Post_SCCD/ParallelState post_ps_3 {
                label = "3"
            }
            Post_SCCD/CompositeState post_cs_4 {
                label = "4"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
            }
            Post_SCCD/parallel_children post_ps_5 (post_ps_3, post_cs_4) {
                label = "5"
            }
            Post_SCCD/BasicState post_bs_6 {
                label = "6"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Waiting"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
                value_onEntryScript = $
                     Element function value(model : Element, name : String, mapping : Element):
                        Element result
                        String code
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function constructor_body (attributes : Element):\n")
                        code = string_join(code, "\tlog(\"INSIDE EXEC WAITING STATE\")\n")
                        code = string_join(code, "\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/BasicState post_bs_7 {
                label = "7"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Running"!
                    $
            }
            Post_SCCD/composite_children post_cc_8 (post_cs_4, post_bs_6) {
                label = "8"
            }
            Post_SCCD/composite_children post_cc_9 (post_cs_4, post_bs_7) {
                label = "9"
            }
            Post_SCCD/transition post_trans_10 (post_bs_6, post_bs_7) {
                label = "10"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tBoolean guard\n")
                        type = read_type(model, mapping["0"])
                        if bool_or(type == "PM/Join", type == "PM/Start"):
                            code = string_join(code, "\treturn value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'], True)!")
                        elif (type == "PM/Decision"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'], True), value_eq(attributes['decision_consumes']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],")
                            code = string_join(code, read_attribute(model, mapping["2"], "value"))
                            code = string_join(code, "))!")
                        elif (type == "PM/Exec"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'], True) , value_eq(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'], True))!")
                        elif (type == "PM/Fork"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'], True), value_eq(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "']['")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "'],False))!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")

                        type = read_type(model, mapping["0"])
                        if bool_or(bool_or(type == "PM/Join", type == "PM/Start"), type == "PM/Decision"):
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "', False)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)\n\tlog(\"START TRIGGERED\")")
                        elif (type == "PM/Fork"):
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "', True)")
                        elif (type == "PM/Exec"):
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "', False)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['finish'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "', False)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)")
                        code = string_join(code, "\n\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/Raise post_re_11 {
                label = "11"
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "spawn_exec"!
                    $
                value_scope = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "local"!
                    $
                value_parameter = $
                    Element function raise(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Element function parameter(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tElement param\n")
                        code = string_join(code, "\tparam = list_create()\n")
                        code = string_join(code, "\tlist_append(param,'")
                        code = string_join(code, read_attribute(model, mapping["1"], "name"))
                        code = string_join(code, "')\n")
                        code = string_join(code, "\treturn param!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                $
            }
            Post_SCCD/ActualParameter post_rap_25 {
                label = "12"
                value_exp = $
                    String function value(model : Element, name : String, mapping : Element):
                        return read_attribute(model, mapping["1"], "name")!
                    $
            }
            Post_SCCD/raise_parameters (post_re_11, post_rap_25) {
                label = "13"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                $
            }
            Post_SCCD/transition_raises (post_trans_10, post_re_11) {
                label = "14"
            }
            Post_SCCD/transition post_etrans_15 (post_bs_7, post_bs_6) {
                label = "15"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "terminated"!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\treturn value_eq('")
                        code = string_join(code, read_attribute(model, mapping["1"], "name"))
                        code = string_join(code, "',parameters[0])!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")

                        type = read_type(model, mapping["0"])
                        if (type == "PM/Fork"):
                            code = string_join(code,"\tdict_overwrite(attributes['finish'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)")
                        else:
                            code = string_join(code, "\tdict_overwrite(attributes['finish'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)")
                        code = string_join(code, "\n\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/FormalParameter post_efp_16 {
                label = "16"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "exec_name"!
                    $
            }
            Post_SCCD/transition_parameters (post_etrans_15, post_efp_16) {
                label = "17"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                    $
            }
            Post_Activity2State_link (post_exec_1, post_cs_4){
            	label = "18"
            }
        }
    }

    {Contains} ForAll data_produces {
        LHS {
            Pre_PM/Exec pre_exec_data_0 {
                label = "0"
            }
            Pre_PM/Data pre_data_1 {
                label = "1"
            }
            Pre_PM/Produces pre_pro_2 (pre_exec_data_0, pre_data_1) {
                label = "2"
            }
            Pre_SCCD/CompositeState pre_co_3 {
                label = "3"
            }
            Pre_Activity2State_link (pre_exec_data_0, pre_co_3){
            	label = "4"
            }
            Pre_SCCD/BasicState pre_bs_5 {
                label = "5"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Running")!
                    $
            }
            Pre_SCCD/composite_children (pre_co_3, pre_bs_5) {
                label = "6"
            }    
        }
        RHS {
            Post_PM/Exec post_exec_data_0 {
                label = "0"
            }
            Post_PM/Data post_data_1 {
                label = "1"
            }
            Post_PM/Produces post_pro_2 (post_exec_data_0, post_data_1) {
                label = "2"
            }
            Post_SCCD/CompositeState post_co_3 {
                label = "3"
            }
            Post_Activity2State_link (post_exec_data_0, post_co_3){
            	label = "4"
            }
            Post_SCCD/BasicState post_pbs_5 {
                label = "5"
            }
            Post_SCCD/composite_children (post_co_3, post_pbs_5) {
                label = "6"
            }
            Post_SCCD/transition post_trans_7 (post_pbs_5, post_pbs_5) {
                label = "7"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "save"!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\treturn value_eq('")
                        code = string_join(code, read_attribute(model, mapping["0"], "name"))
                        code = string_join(code, "',parameters[1])!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\tdict_overwrite(attributes['data'], parameters[0], False)")
                        code = string_join(code, "\n\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/FormalParameter post_fp_8 {
                label = "8"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "data_name"!
                    $
            }
            Post_SCCD/FormalParameter post_fp_9 {
                label = "9"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "exec_name"!
                    $
            }
            Post_SCCD/transition_parameters (post_trans_7, post_fp_8) {
                label = "10"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                    $
            }
            Post_SCCD/transition_parameters (post_trans_7, post_fp_9) {
                label = "11"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 1!
                    $
            }
        }
    }

    {Contains} ForAll exec_data_consumes {
        LHS {
            Pre_PM/Exec pre_exec_consumes_0 {
                label = "0"
            }
            Pre_PM/Data pre_data_consumes_1 {
                label = "1"
            }
            Pre_PM/Consumes pre_con_2 (pre_exec_consumes_0, pre_data_consumes_1) {
                label = "2"
            }
            Pre_SCCD/CompositeState pre_cs_3 {
                label = "3"
            }
            Pre_Activity2State_link (pre_exec_consumes_0, pre_cs_3){
            	label = "4"
            }
            Pre_SCCD/BasicState pre_consumes_bs_5 {
                label = "5"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Running")!
                    $
            }
            Pre_SCCD/composite_children (pre_cs_3, pre_consumes_bs_5) {
                label = "6"
            }    
        }
        RHS {
            Post_PM/Exec post_exec_consumes_0 {
                label = "0"
            }
            Post_PM/Data post_data_consumes_1 {
                label = "1"
            }
            Post_PM/Consumes post_con_2 (post_exec_consumes_0, post_data_consumes_1) {
                label = "2"
            }
            Post_SCCD/CompositeState post_ccs_3 {
                label = "3"
            }
            Post_Activity2State_link (post_exec_consumes_0, post_ccs_3){
            	label = "4"
            }
            Post_SCCD/BasicState post_bs_consumes_5 {
                label = "5"
            }
            Post_SCCD/composite_children (post_ccs_3, post_bs_consumes_5) {
                label = "6"
            }
            Post_SCCD/transition post_trans_consumes_7 (post_bs_consumes_5, post_bs_consumes_5) {
                label = "7"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "load"!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\treturn value_eq('")
                        code = string_join(code, read_attribute(model, mapping["0"], "name"))
                        code = string_join(code, "',parameters[1])!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/FormalParameter post_trans_fp_8 {
                label = "8"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "data_name"!
                    $
            }
            Post_SCCD/FormalParameter post_trans_fp_9 {
                label = "9"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "exec_name"!
                    $
            }
            Post_SCCD/transition_parameters (post_trans_consumes_7, post_trans_fp_8) {
                label = "10"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                    $
            }
            Post_SCCD/transition_parameters (post_trans_consumes_7, post_trans_fp_9) {
                label = "11"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 1!
                    $
            }
            Post_SCCD/Raise post_re_12 {
                label = "12"
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "load"!
                    $
                value_scope = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "narrow"!
                    $
                value_target = $
                    String function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "String function target(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\treturn attributes['assn_names']['")
                        code = string_join(code, read_attribute(model, mapping["0"], "name"))
                        code = string_join(code, "']!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/ActualParameter post_ap_13 {
                label = "13"
                value_exp = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "String function exp(attributes : Element, parameters : Element):\n")
                        code = string_join(code, "\treturn attributes['data'][parameters[0]]!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
			Post_SCCD/raise_parameters (post_re_12, post_ap_13) {
                label = "14"
                value_order = $
                    Integer function value(model : Element, name : String, mapping : Element):
                        return 0!
                    $
            }
            Post_SCCD/transition_raises (post_trans_consumes_7, post_re_12){
            	label = "15"
            }
        }
    }

    {Contains} ForAll map_decision {
        LHS {
            Pre_PM/Activity pre_0 {
                label = "0" 
            }
            Pre_PM/Decision pre_1 {
                label = "1"
            }
            Pre_PM/Next (pre_0, pre_1) {
                label = "2"
            }
            Pre_PM/Data pre_3 {
                label = "3"
            }
            Pre_PM/DecisionConsumes (pre_1, pre_3) {
                label = "4"
            }
            Pre_SCCD/ParallelState pre_5 {
                label = "5"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Running")!
                    $
            }
            constraint = $
                Boolean function constraint (model : Element, mapping : Element):
                    Element children 
                    String parent
                    Element class_beh 
                    String class

                    children = allIncomingAssociationInstances(model, mapping["5"], "SCCD/composite_children")
                    if list_len(children) >0:
                        parent = readAssociationSource(model, set_pop(children))
                        class_beh = allIncomingAssociationInstances(model, parent, "SCCD/behaviour")
                        if list_len(class_beh) >0:
                            class = readAssociationSource(model, set_pop(class_beh))
                            if (value_eq(read_attribute(model, class, "name"), "Orchestrator")):
                                return True!
                            else:
                                return False!
                        else:
                            return False!
                    else:
                        return False!
                $
        }
        RHS {
            Post_PM/Activity post_0 {
                label = "0" 
            }
            Post_PM/Decision post_1 {
                label = "1"
            }
            Post_PM/Next (post_0, post_1) {
                label = "2"
            }
            Post_PM/Data post_3 {
                label = "3"
            }
            Post_PM/DecisionConsumes (post_1, post_3) {
                label = "4"
            }
            Post_SCCD/ParallelState post_5 {
                label = "5"
            }
            Post_SCCD/CompositeState post_6 {
                label = "6"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
            }
           	Post_SCCD/parallel_children (post_5, post_6) {
                label = "7"
            }
            Post_SCCD/BasicState post_8 {
                label = "8"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Waiting"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/composite_children (post_6, post_8) {
                label = "9"
            }
            Post_SCCD/transition post_10(post_8, post_8) {
                label = "10"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")

                        type = read_type(model, mapping["0"])
                        if bool_or(type == "PM/Join", type == "PM/Start"):
                            code = string_join(code, "\treturn value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'], True)!")
                        elif (type == "PM/Decision"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'], True),value_eq(attributes['decision_consumes']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],")
                            code = string_join(code, read_attribute(model, mapping["2"], "value"))
                            code = string_join(code, "))!")
                        elif (type == "PM/Exec"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True), value_eq(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True))!")
                        elif (type == "PM/Fork"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True),value_eq(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "']['")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "'],False))!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    String function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function cond(attributes : Element, parameters : Element):\n")

                        type = read_type(model, mapping["0"])
                        if bool_or(bool_or(type == "PM/Join", type == "PM/Start"), type == "PM/Decision"):
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "',False)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['decision_consumes'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',attributes['data']['")
                            code = string_join(code, read_attribute(model, mapping["3"], "name"))
                            code = string_join(code, "'])")
                        elif (type == "PM/Fork"):
                            code = string_join(code,"\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)\n")
                            code = string_join(code, "\tdict_overwrite(attributes['decision_consumes'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "', attributes['data']['")
                            code = string_join(code, read_attribute(model, mapping["3"], "name"))
                            code = string_join(code, "'])")
                        elif (type == "PM/Exec"):
                            code = string_join(code,"\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "',False) \n")
                            code = string_join(code, "\tdict_overwrite(attributes['finish'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "',False) \n")
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True) \n")
                            code = string_join(code, "\tdict_overwrite(attributes['decision_consumes'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "', attributes['data']['")
                            code = string_join(code, read_attribute(model, mapping["3"], "name"))
                            code = string_join(code, "'])")
                        code = string_join(code, "\n\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_Activity2State_link (post_1, post_6){
            	label = "11"
            }
        }         
    }

    {Contains} ForAll map_fork {
        LHS {
            Pre_PM/Activity pre_f_0 {
                label = "0" 
            }
            Pre_PM/Fork pre_f_1 {
                label = "1"
            }
            Pre_PM/Next (pre_f_0, pre_f_1) {
                label = "2"
            } 
            Pre_SCCD/ParallelState pre_f_3 {
                label = "3"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Running")!
                    $
            }
            constraint = $
                Boolean function constraint (model : Element, mapping : Element):
                    Element children 
                    String parent
                    Element class_beh 
                    String class

                    children = allIncomingAssociationInstances(model, mapping["3"], "SCCD/composite_children")
                    if list_len(children) >0:
                        parent = readAssociationSource(model, set_pop(children))
                        class_beh = allIncomingAssociationInstances(model, parent, "SCCD/behaviour")
                        if list_len(class_beh) >0:
                            class = readAssociationSource(model, set_pop(class_beh))
                            if (value_eq(read_attribute(model, class, "name"), "Orchestrator")):
                                return True!
                            else:
                                return False!
                        else:
                            return False!
                    else:
                        return False!
                $
        }
        RHS {
            Post_PM/Activity post_f_0 {
                label = "0" 
            }
            Post_PM/Fork post_f_1 {
                label = "1"
            }
            Post_PM/Next (post_f_0, post_f_1) {
                label = "2"
            }
            Post_SCCD/ParallelState post_f_3 {
                label = "3"
            }
            Post_SCCD/CompositeState post_f_6 {
                label = "6"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
            }
           	Post_SCCD/parallel_children (post_f_3, post_f_6) {
                label = "7"
            }
            Post_SCCD/BasicState post_f_8 {
                label = "8"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Waiting"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/BasicState post_f_9 {
                label = "9"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Running"!
                    $
            }
            Post_SCCD/composite_children (post_f_6, post_f_8) {
                label = "10"
            }
            Post_SCCD/composite_children (post_f_6, post_f_9) {
                label = "11"
            }
            Post_SCCD/transition post_f_12(post_f_8, post_f_9) {
                label = "12"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_cond = $
                    String function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")

                        type = read_type(model, mapping["0"])
                        if bool_or(type == "PM/Join", type == "PM/Start"):
                            code = string_join(code,"\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True), value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "'],False))!")
                        elif (type == "PM/Decision"):
                            code = string_join(code,"\treturn bool_and(bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True), value_eq(attributes['decision_consumes']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],")
                            code = string_join(code, read_attribute(model, mapping["2"], "value"))
                            code = string_join(code, ")), value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "'],False))!")
                        elif (type == "PM/Exec"):
                            code = string_join(code,"\treturn bool_and(bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True), value_eq(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True)), value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "'],False))!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    String function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")

                        type = read_type(model, mapping["0"])
                        if bool_or(bool_or(type == "PM/Join", type == "PM/Start"), type == "PM/Decision"):
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "',False) \n")
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)")
                        elif (type == "PM/Exec"):
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "',False) \n")
                            code = string_join(code, "\tdict_overwrite(attributes['finish'],'")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "',False) \n")
                            code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                            code = string_join(code, "',True)")
                        code = string_join(code, "\n\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/transition post_f_13(post_f_9, post_f_8) {
                label = "13"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String joined_str
                        Element outgoing_assns
                        String edge
                        String activity
                        Element pairs
                        String last_operand
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")

                        last_operand = ""
                        pairs = create_node()
                        outgoing_assns = allOutgoingAssociationInstances(model, mapping["1"], "PM/Next")
                        while (read_nr_out(outgoing_assns) > 0):
                            edge = set_pop(outgoing_assns)
                            activity = readAssociationDestination(model, edge)
                            if list_len(outgoing_assns)>1:
                                joined_str = string_join("bool_and(value_eq(attributes['finish']['", read_attribute(model, mapping["1"], "id"))
                                joined_str = string_join(joined_str, "']['")
                                joined_str = string_join(joined_str,read_attribute(model, activity, "id"))
                                joined_str = string_join(joined_str, "'],True), value_eq(attributes['finish']['")
                                joined_str = string_join(joined_str, read_attribute(model, mapping["1"], "id"))
                                joined_str = string_join(joined_str, "']['")
                                edge = set_pop(outgoing_assns)
                                activity = readAssociationDestination(model, edge)
                                joined_str = string_join(joined_str,read_attribute(model, activity, "id"))
                                joined_str = string_join(joined_str, "'],True))")
                                list_append(pairs, joined_str)
                            else:
                                joined_str = string_join("value_eq(attributes['finish']['", read_attribute(model, mapping["1"], "id"))
                                joined_str = string_join(joined_str, "']['")
                                joined_str = string_join(joined_str,read_attribute(model, activity, "id"))
                                joined_str = string_join(joined_str, "'],True)")
                                last_operand = joined_str

                        joined_str = ""
                        if list_len(pairs)>1:
                            Integer i
                            i = 0
                            while (i < list_len(pairs)):
                                if joined_str == "":
                                    joined_str = string_join("bool_and(", list_read(pairs, i))
                                    i = i + 1
                                    joined_str = string_join(joined_str," , ")
                                    joined_str = string_join(joined_str, list_read(pairs, i))
                                    i = i + 1
                                    joined_str = string_join(joined_str, ")")
                                else:
                                    joined_str = string_join("bool_and(", joined_str)
                                    joined_str = string_join(joined_str, ",")
                                    joined_str = string_join(joined_str, list_read(pairs, i))
                                    i = i + 1
                                    joined_str = string_join(joined_str, ")")
                            if last_operand != "":
                                joined_str = string_join("bool_and(", joined_str)
                                joined_str = string_join(joined_str, ",")
                                joined_str = string_join(joined_str, last_operand)
                                joined_str = string_join(joined_str, ")")
                        elif bool_and(last_operand != "", list_len(pairs) == 1):
                            joined_str = string_join("bool_and(", list_read(pairs, 0))
                            joined_str = string_join(joined_str, ",")
                            joined_str = string_join(joined_str, last_operand)
                            joined_str = string_join(joined_str, ")")
                        elif list_len(pairs) == 1:
                            joined_str = list_read(pairs, 0)
                        code = string_join(code, "\treturn ")
                        code = string_join(code, joined_str)
                        code = string_join(code, "!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        Element outgoing_assns
                        String edge
                        String activity
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")

                        code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                        code = string_join(code, read_attribute(model, mapping["1"], "id"))
                        code = string_join(code, "', False)\n")
                        outgoing_assns = allOutgoingAssociationInstances(model, mapping["1"], "PM/Next")
                        while (read_nr_out(outgoing_assns) > 0):
                            edge = set_pop(outgoing_assns)
                            activity = readAssociationDestination(model, edge)
                            code = string_join(code, "\tdict_overwrite(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["1"], "id"))
                        	code = string_join(code, "'],'")
                            code = string_join(code,read_attribute(model, activity, "id"))
                            code = string_join(code, "', False)\n")
                        code = string_join(code, "\n\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_Activity2State_link (post_f_1, post_f_6){
            	label = "14"
            }
        }         
    }

    {Contains} ForAll map_join {
        LHS {
            Pre_PM/Join pre_j_0 {
                label = "0" 
            }
            Pre_SCCD/ParallelState pre_j_1 {
                label = "1"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Running")!
                    $
            }
            constraint = $
                Boolean function constraint (model : Element, mapping : Element):
                    Element children 
                    String parent
                    Element class_beh 
                    String class

                    children = allIncomingAssociationInstances(model, mapping["1"], "SCCD/composite_children")
                    if list_len(children) >0:
                        parent = readAssociationSource(model, set_pop(children))
                        class_beh = allIncomingAssociationInstances(model, parent, "SCCD/behaviour")
                        if list_len(class_beh) >0:
                            class = readAssociationSource(model, set_pop(class_beh))
                            if (value_eq(read_attribute(model, class, "name"), "Orchestrator")):
                                return True!
                            else:
                                return False!
                        else:
                            return False!
                    else:
                        return False!
                $
        }
        RHS {
            Post_PM/Join post_j_0 {
                label = "0" 
            } 
            Post_SCCD/ParallelState post_j_1 {
                label = "1"
            }
            Post_SCCD/CompositeState post_j_6 {
                label = "6"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
            }
           	Post_SCCD/parallel_children (post_j_1, post_j_6) {
                label = "7"
            }
            Post_SCCD/BasicState post_j_8 {
                label = "8"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Waiting"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/composite_children (post_j_6, post_j_8) {
                label = "9"
            }
            Post_SCCD/transition post_j_10(post_j_8, post_j_8) {
                label = "10"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String joined_str
                        Element incoming_assns
                        String edge
                        String type
                        String activity
                        Element pairs
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")

                        pairs = create_node()
                        incoming_assns = allIncomingAssociationInstances(model, mapping["0"], "PM/Next")
                        while (read_nr_out(incoming_assns) > 0):
                            edge = set_pop(incoming_assns)
                            activity = readAssociationSource(model, edge)
                            type = read_type(model, activity)
                        	if (type == "PM/Exec"):
                                joined_str = string_join("bool_and(value_eq(attributes['finish']['",read_attribute(model, activity, "id"))
                            	joined_str = string_join(joined_str, "'],True), value_eq(attributes['token']['")
                                joined_str = string_join(joined_str,read_attribute(model, activity, "id"))
                                joined_str = string_join(joined_str, "'], True))")
                                list_append(pairs, joined_str)
                            elif (type == "PM/Decision"):
                                joined_str = string_join("bool_and(value_eq(attributes['token']['", read_attribute(model, activity, "id"))
                            	joined_str = string_join(joined_str, "'],True), value_eq(attributes['decision_consumes']['")
                                joined_str = string_join(joined_str,read_attribute(model, activity, "id"))
                                joined_str = string_join(joined_str, "'],")
                                joined_str = string_join(joined_str,read_attribute(model, edge, "value"))
                                joined_str = string_join(joined_str, "))")
                                list_append(pairs, joined_str)
                            elif (type == "PM/Join"):
                                joined_str = string_join("value_eq(attributes['token']['", read_attribute(model, activity, "id"))
                            	joined_str = string_join(joined_str, "'],True)")
                            	list_append(pairs, joined_str)
                            elif (type == "PM/Fork"):
                                joined_str = string_join("bool_and(value_eq(attributes['token']['", read_attribute(model, activity, "id"))
                            	joined_str = string_join(joined_str, "'],True), value_eq(attributes['finish']['")
                            	joined_str = string_join(joined_str, read_attribute(model, activity, "id"))
                            	joined_str = string_join(joined_str, "'],'")
                            	joined_str = string_join(joined_str, read_attribute(model, mapping["0"], "id"))
                            	joined_str = string_join(joined_str, "',False))")
                            	list_append(pairs, joined_str)
                        joined_str = ""
                        if list_len(pairs)>1:
                            Integer i
                            i = 0
                            while (i < list_len(pairs)):
                                if joined_str == "":
                                    joined_str = string_join("\treturn bool_and(", list_read(pairs,i))
                                    i = i + 1
                                    joined_str = string_join(joined_str," , ")
                                    joined_str = string_join(joined_str, list_read(pairs,i))
                                    i = i + 1
                                    joined_str = string_join(joined_str, ")")
                                else:
                                    joined_str = string_join("bool_and(", joined_str)
                                    joined_str = string_join(joined_str, ",")
                                    joined_str = string_join(joined_str, list_read(pairs, i))
                                    i = i + 1
                                    joined_str = string_join(joined_str, ")")
                        elif value_eq(list_len(pairs), 1):
                            joined_str = string_join("\treturn ", list_read(pairs, 0))

                        code = string_join(code, joined_str)
                        code = string_join(code, "!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        Element outgoing_assns
                        String edge
                        String type
                        String activity
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")

                        outgoing_assns = allIncomingAssociationInstances(model, mapping["0"], "PM/Next")
                        code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                        code = string_join(code, read_attribute(model, mapping["0"], "id"))
                        code = string_join(code, "',True)\n")
                        while (read_nr_out(outgoing_assns) > 0):
                            edge = set_pop(outgoing_assns)
                            activity = readAssociationSource(model, edge)
                            type = read_type(model, activity)
                        	if (type == "PM/Exec"):
                                code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                                code = string_join(code, read_attribute(model, activity, "id"))
                            	code = string_join(code, "',False) \n")
                            	code = string_join(code, "\tdict_overwrite(attributes['finish'],'")
                                code = string_join(code, read_attribute(model, activity, "id"))
                                code = string_join(code, "',False)\n")
                            elif bool_or(type == "PM/Decision", type == "PM/Join"):
                                code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                            	code = string_join(code, read_attribute(model, activity, "id"))
                            	code = string_join(code, "', False)\n")
                            elif type == "PM/Fork":
                                code = string_join(code, "\tdict_overwrite(attributes['finish'],['")
                            	code = string_join(code, read_attribute(model, activity, "id"))
                            	code = string_join(code, "'], '")
                            	code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            	code = string_join(code, "', True)\n")
                        code = string_join(code, "\n\treturn!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            
            Post_Activity2State_link (post_j_0, post_j_6){
            	label = "14"
            }
        }         
    }

    {Contains} ForAll map_finish {
        LHS {
            Pre_PM/Activity pre_e_0 {
                label = "0" 
            }
            Pre_PM/Finish pre_e_1 {
                label = "1" 
            }
            Pre_SCCD/ParallelState pre_e_2 {
                label = "2"
                constraint_name = $
                    Boolean function constraint(value : String):
                        return (value == "Running")!
                    $
            }
            Pre_PM/Next (pre_e_0, pre_e_1){
            	label = "11"
            }
            constraint = $
                Boolean function constraint (model : Element, mapping : Element):
                    Element children 
                    String parent
                    Element class_beh 
                    String class

                    children = allIncomingAssociationInstances(model, mapping["2"], "SCCD/composite_children")
                    if list_len(children) >0:
                        parent = readAssociationSource(model, set_pop(children))
                        class_beh = allIncomingAssociationInstances(model, parent, "SCCD/behaviour")
                        if list_len(class_beh) >0:
                            class = readAssociationSource(model, set_pop(class_beh))
                            if (value_eq(read_attribute(model, class, "name"), "Orchestrator")):
                                return True!
                            else:
                                return False!
                        else:
                            return False!
                    else:
                        return False!
                $
        }
        RHS {
            Post_PM/Activity post_e_0 {
                label = "0" 
            } 
            Post_PM/Finish post_e_1 {
                label = "1" 
            }
            Post_PM/Next (post_e_0, post_e_1){
            	label = "11"
            } 
            Post_SCCD/ParallelState post_e_2 {
                label = "2"
            }
            Post_SCCD/CompositeState post_e_3 {
                label = "3"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
            }
           	Post_SCCD/parallel_children (post_e_2, post_e_3) {
                label = "4"
            }
            Post_SCCD/BasicState post_e_5 {
                label = "5"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "Waiting"!
                    $
                value_isInitial = $
                    Boolean function value(model : Element, name : String, mapping : Element):
                        return True!
                    $
            }
            Post_SCCD/composite_children (post_e_3, post_e_5) {
                label = "6"
            }
            Post_SCCD/transition post_e_7(post_e_5, post_e_5) {
                label = "7"
                value_name = $
                    String function value(model : Element, name : String, mapping : Element):
                        return name!
                    $
                value_cond = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String type
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Boolean function cond(attributes : Element, parameters : Element):\n")

                        type = read_type(model, mapping["0"])
                        if bool_or(bool_or(type == "PM/Join", type == "PM/Fork"),type=="PM/Start"):
                            code = string_join(code, "\treturn value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True)!")
                        elif (type == "PM/Decision"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True), value_eq(attributes['decision_consumes']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],")
                            code = string_join(code, read_attribute(model, mapping["11"], "value"))
                            code = string_join(code, "))!")
                        elif (type == "PM/Exec"):
                            code = string_join(code, "\treturn bool_and(value_eq(attributes['token']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True), value_eq(attributes['finish']['")
                            code = string_join(code, read_attribute(model, mapping["0"], "id"))
                            code = string_join(code, "'],True))!")
                        result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
                value_script = $
                    Element function value(model : Element, name : String, mapping : Element):
                        String code
                        Element result
                        code = "include \"primitives.alh\"\n"
                        code = string_join(code, "Void function script(attributes : Element, parameters : Element):\n")
                        code = string_join(code,"\tdict_overwrite(attributes['token'],'")
                        code = string_join(code, read_attribute(model, mapping["0"], "id"))
                        code = string_join(code, "',False) \n")
                        code = string_join(code, "\tdict_overwrite(attributes['token'],'")
                        code = string_join(code, read_attribute(model, mapping["1"], "id"))
                       	code = string_join(code, "',True)")
                       	code = string_join(code, "\n\treturn!")

                       	result = compile_code(code)
                        if element_eq(result, read_root()):
                            return read_root()!
                        else:
                            return result!
                    $
            }
            Post_SCCD/Raise post_e_8 {
                label = "8"
                value_event = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "process_done"!
                    $
                value_scope = $
                    String function value(model : Element, name : String, mapping : Element):
                        return "local"!
                    $
            }
			Post_SCCD/transition_raises (post_e_7, post_e_8) {
                label = "9"
            }
            Post_Activity2State_link (post_e_1, post_e_3){
            	label = "10"
            }
        }         
    }

}
Initial (schedule, create_orchestrator) {}

OnSuccess (create_orchestrator, create_class_association) {}
OnSuccess (create_class_association, ModifyFork2Fork) {}
OnSuccess (ModifyFork2Fork, ModifyFork2Fork) {}
OnSuccess (RemoveFork2Fork, initialize) {}
OnSuccess (initialize, compile_init_script) {}
OnSuccess (compile_init_script, map_exec) {}
OnSuccess (map_exec, data_produces) {}
OnSuccess (data_produces, exec_data_consumes) {}
OnSuccess (exec_data_consumes, map_decision) {}
OnSuccess (map_decision, map_fork) {}
OnSuccess (map_fork, map_join) {}
OnSuccess (map_join, map_finish) {}
OnSuccess (map_finish, success) {}

OnFailure (create_orchestrator, create_class_association) {}
OnFailure (create_class_association, ModifyFork2Fork) {}
OnFailure (ModifyFork2Fork, RemoveFork2Fork) {}
OnFailure (RemoveFork2Fork, initialize) {}
OnFailure (initialize, compile_init_script) {}
OnFailure (compile_init_script, map_exec) {}
OnFailure (map_exec, data_produces) {}
OnFailure (data_produces, exec_data_consumes) {}
OnFailure (exec_data_consumes, map_decision) {}
OnFailure (map_decision, map_fork) {}
OnFailure (map_fork, map_join) {}
OnFailure (map_join, map_finish) {}
OnFailure (map_finish, success) {}