Rule Access_Eval_N1 {
    Root N1_0 {}
    Match N1_1 {
        match = True
    }
    Match N1_2 {
        match = True
    }
    Match N1_3 {
        value = "!access"
        match = True
    }
    Match N1_4 {
        value = "'eval'"
        match = True
    }
    Create N1_5 {
        value = "'finish'"
    }
    Match N1_6 {}
    Match N1_7 {}

    MatchEdge (N1_0, N1_1) {
        value = "taskname"
    }
    MatchEdge (N1_1, N1_2) {
        value = "'frame'"
    }
    MatchEdge (N1_2, N1_3) {
        value = "'IP'"
    }
    DeleteEdge (N1_2, N1_4) {
        value = "'phase'"
    }
    CreateEdge (N1_2, N1_5) {
        value = "'phase'"
    }
    CreateEdge (N1_2, N1_6) {
        value = "'returnvalue'"
    }
    DeleteEdge (N1_2, N1_7) {
        value = "'returnvalue'"
    }
    MatchEdge (N1_7, N1_6) {
        value = "'value'"
    }
}

Rule Access_Init_N2 {
    Root N2_0 {}
    Match N2_1 {
        match = True
    }
    Match N2_2 {
        match = True
    }
    Match N2_3 {
        match = True
        value = "'init'"
    }
    Create N2_4 {}
    Match N2_5 {
        match = True
        value = "!access"
    }
    Match N2_6 {}
    Match N2_7 {}
    Create N2_8 {
        value = "'eval'"
    }

    MatchEdge (N2_0, N2_1) {
        value = "taskname"
    }
    MatchEdge (N2_1, N2_2) {
        value = "'frame'"
    }
    MatchEdge (N2_2, N2_3) {
        value = "'phase'"
    }
    DeleteEdge (N2_2, N2_5) {
        value = "'IP'"
    }
    CreateEdge (N2_2, N2_4) {
        value = "'evalstack'"
    }
    DeleteEdge (N2_2, N2_6) {
        value = "'evalstack'"
    }
    CreateEdge (N2_2, N2_7) {
        value = "'IP'"
    }
    CreateEdge (N2_4, N2_6) {
        value = "'prev'"
    }
    CreateEdge (N2_6, N2_8) {
        value = "'phase'"
    }
    CreateEdge (N2_6, N2_5) {
        value = "'inst'"
    }
    MatchEdge (N2_5, N2_7) {
        value = "'var'"
    }
}

Rule Assign_Assign_N3 {
    Root N3_0 {}
    Match N3_1 {
        match = True
    }
    Match N3_2 {
        match = True
    }
    Match N3_3 {
        match = True
        value = "!assign"
    }
    Match N3_4 {
        match = True
        value = "'assign'"
    }
    Create N3_5 {
        value = "'finish'"
    }
    Match N3_6 {}
    Match N3_7 {}
    Match N3_8 {}

    MatchEdge (N3_0, N3_1) {
        value = "taskname"
    }
    MatchEdge (N3_1, N3_2) {
        value = "'frame'"
    }
    MatchEdge (N3_2, N3_3) {
        value = "'IP'"
    }
    DeleteEdge (N3_2, N3_4) {
        value = "'phase'"
    }
    CreateEdge (N3_2, N3_5) {
        value = "'phase'"
    }
    MatchEdge (N3_2, N3_6) {
        value = "'returnvalue'"
    }
    DeleteEdge (N3_2, N3_7) {
        value = "'variable'"
    }
    CreateEdge (N3_7, N3_6) {
        value = "'value'"
    }
    DeleteEdge (N3_7, N3_8) {
        value = "'value'"
    }
}

Rule Assign_Init_N4 {
    Root N4_0 {}
    Match N4_1 {
        match = True
    }
    Match N4_2 {
        match = True
    }
    Match N4_3 {
        match = True
        value = "'init'"
    }
    Create N4_4 {}
    Match N4_5 {}
    Match N4_6 {
        match = True
        value = "!assign"
    }
    Create N4_7 {
        value = "'value'"
    }
    Match N4_8 {}

    MatchEdge (N4_0, N4_1) {
        value = "taskname"
    }
    MatchEdge (N4_1, N4_2) {
        value = "'frame'"
    }
    MatchEdge (N4_2, N4_3) {
        value = "'phase'"
    }
    DeleteEdge (N4_2, N4_6) {
        value = "'IP'"
    }
    CreateEdge (N4_2, N4_4) {
        value = "'evalstack'"
    }
    DeleteEdge (N4_2, N4_5) {
        value = "'evalstack'"
    }
    CreateEdge (N4_2, N4_8) {
        value = "'IP'"
    }
    CreateEdge (N4_4, N4_5) {
        value = "'prev'"
    }
    CreateEdge (N4_5, N4_6) {
        value = "'inst'"
    }
    CreateEdge (N4_5, N4_7) {
        value = "'phase'"
    }
    MatchEdge (N4_6, N4_8) {
        value = "'var'"
    }
}

Rule Assign_Value_N5 {
    Root N5_0 {}
    Match N5_1 {
        match = True
    }
    Match N5_2 {
        match = True
    }
    Match N5_3 {
        match = True
        value = "'value'"
    }
    Match N5_4 {
        match = True
        value = "!assign"
    }
    Create N5_5 {}
    Create N5_6 {
        value = "'init'"
    }
    Match N5_7 {}
    Match N5_8 {}
    Match N5_9 {}
    Create N5_10 {
        value = "'assign'"
    }

    MatchEdge (N5_0, N5_1) {
        value = "taskname"
    }
    MatchEdge (N5_1, N5_2) {
        value = "'frame'"
    }
    DeleteEdge (N5_2, N5_3) {
        value = "'phase'"
    }
    DeleteEdge (N5_2, N5_4) {
        value = "'IP'"
    }
    CreateEdge (N5_2, N5_5) {
        value = "'evalstack'"
    }
    CreateEdge (N5_2, N5_6) {
        value = "'phase'"
    }
    DeleteEdge (N5_2, N5_9) {
        value = "'evalstack'"
    }
    CreateEdge (N5_2, N5_7) {
        value = "'IP'"
    }
    MatchEdge (N5_2, N5_8) {
        value = "'returnvalue'"
    }
    CreateEdge (N5_2, N5_8) {
        value = "'variable'"
    }
    CreateEdge (N5_5, N5_9) {
        value = "'prev'"
    }
    CreateEdge (N5_9, N5_4) {
        value = "'inst'"
    }
    CreateEdge (N5_9, N5_10) {
        value = "'phase'"
    }
    MatchEdge (N5_4, N5_7) {
        value = "'value'"
    }
}

Rule Break_N6 {
    Root N6_0 {}
    Match N6_1 {
        match = True
    }
    Match N6_2 {
        match = True
    }
    Match N6_3 {
        value = "'init'"
        match = True
    }
    Create N6_4 {
        value = "'finish'"
    }
    Match N6_5 {
        value = "!break"
        match = True
    }
    Match N6_6 {
        value = "!while"
    }
    Match N6_7 {}
    Match N6_8 {}
    Create N6_9 {}
    Match N6_10 {}
    Create N6_11 {
        value = "'finish'"
    }
    Match N6_12 {}

    MatchEdge (N6_0, N6_1) {
        value = "taskname"
    }
    MatchEdge (N6_1, N6_2) {
        value = "'frame'"
    }
    DeleteEdge (N6_2, N6_3) {
        value = "'phase'"
    }
    CreateEdge (N6_2, N6_4) {
        value = "'phase'"
    }
    MatchEdge (N6_2, N6_5) {
        value = "'IP'"
    }
    MatchEdge (N6_5, N6_6) {
        value = "'while'"
    }
    DeleteEdge (N6_2, N6_7) {
        value = "'evalstack'"
    }
    MatchEdge (N6_8, N6_6) {
        value = "taskname"
    }
    DeleteEdge (N6_10, N6_8) {
        value = "'prev'"
    }
    CreateEdge (N6_2, N6_9) {
        value = "'evalstack'"
    }
    CreateEdge (N6_9, N6_8) {
        value = "'prev'"
    }
    CreateEdge (N6_8, N6_11) {
        value = "'phase'"
    }
}

Rule Call_Call_None_N7 {
    Root N7_0 {}
    Match N7_1 {
        match = True
    }
    Create N7_2 {}
    Match N7_3 {
        match = True
    }
    Create N7_4 {}
    Create N7_5 {}
    Match N7_6 {
        value = "!call"
        match = True
    }
    Create N7_7 {}
    Match N7_8 {}
    Create N7_9 {
        value = "'finish'"
    }
    Match N7_10 {
        value = "'call'"
        match = True
    }
    NAC N7_11 {
        match = True
    }
    Match N7_12 {}
    Create N7_13 {
        value = "'init'"
    }

    MatchEdge (N7_0, N7_1) {
        value = "taskname"
    }
    CreateEdge (N7_1, N7_2) {
        value = "'frame'"
    }
    DeleteEdge (N7_1, N7_3) {
        value = "'frame'"
    }
    CreateEdge (N7_2, N7_4) {
        value = "'evalstack'"
    }
    CreateEdge (N7_2, N7_5) {
        value = "'symbols'"
    }
    CreateEdge (N7_2, N7_6) {
        value = "'caller'"
    }
    CreateEdge (N7_2, N7_7) {
        value = "'returnvalue'"
    }
    CreateEdge (N7_2, N7_12) {
        value = "'IP'"
    }
    CreateEdge (N7_2, N7_13) {
        value = "'phase'"
    }
    NACEdge (N7_6, N7_11) {
        value = "'last_param'"
    }
    CreateEdge (N7_2, N7_3) {
        value = "'prev'"
    }
    MatchEdge (N7_3, N7_6) {
        value = "'IP'"
    }
    MatchEdge (N7_3, N7_8) {
        value = "'returnvalue'"
    }
    CreateEdge (N7_3, N7_9) {
        value = "'phase'"
    }
    DeleteEdge (N7_3, N7_10) {
        value = "'phase'"
    }
    MatchEdge (N7_8, N7_12) {
        value = "'body'"
    }
}

Rule Call_Call_Params_N8 {
    Root N8_0 {}
    Match N8_1 {
        match = True
    }
    Match N8_2 {}
    Match N8_3 {
        match = True
    }
    Match N8_4 {
        value = "!call"
        match = True
    }
    Match N8_5 {
        match = True
    }
    Match N8_6 {
        value = "a"
    }
    Create N8_7 {
        value = "'finish'"
    }
    Match N8_8 {}
    Match N8_9 {}
    Create N8_10 {}
    Match N8_11 {}
    Match N8_12 {}
    Match N8_13 {}
    Match N8_14 {
        value = "'call'"
        match = True
    }
    Match N8_15 {}

    MatchEdge (N8_0, N8_1) {
        value = "taskname"
    }
    CreateEdge (N8_1, N8_2) {
        value = "'frame'"
    }
    DeleteEdge (N8_1, N8_3) {
        value = "'frame'"
    }
    MatchEdge (N8_2, N8_4) {
        value = "'caller'"
    }
    MatchEdge (N8_2, N8_3) {
        value = "'prev'"
    }
    MatchEdge (N8_2, N8_15) {
        value = "'symbols'"
    }
    MatchEdge (N8_2, N8_13) {
        value = "'IP'"
    }
    MatchEdge (N8_3, N8_4) {
        value = "'IP'"
    }
    CreateEdge (N8_3, N8_7) {
        value = "'phase'"
    }
    MatchEdge (N8_3, N8_8) {
        value = "'returnvalue'"
    }
    DeleteEdge (N8_3, N8_14) {
        value = "'phase'"
    }
    MatchEdge (N8_4, N8_5) {
        value = "'last_param'"
    }
    MatchEdge (N8_5, N8_6) {
        value = "'name'"
    }
    CreateEdge (N8_10, N8_8) {
        value = "'value'"
    }
    MatchEdge (N8_11, N8_9) {
        value = "a"
    }
    MatchEdge (N8_12, N8_13) {
        value = "'body'"
    }
    MatchEdge (N8_12, N8_11) {
        value = "'params'"
    }
    CreateEdge N8_16 (N8_15, N8_10) {}
    CreateEdge (N8_16, N8_9) {}
}

Rule Call_Params_First_Multi_N9 {
    Root N9_0 {}
    Match N9_1 {
        match = True
    }
    Match N9_2 {
        match = True
    }
    Create N9_3 {}
    Create N9_4 {
        value = "'init'"
    }
    Create N9_5 {}
    Create N9_6 {}
    Create N9_7 {}
    Match N9_8 {}
    Match N9_9 {}
    Match N9_10 {}
    Create N9_11 {
        value = "'init'"
    }
    Create N9_12 {}
    Match N9_13 {}
    Match N9_14 {
        value = "!call"
        match = True
    }
    Match N9_15 {
        match = True
    }
    Match N9_16 {
        match = True
    }
    Match N9_17 {}

    MatchEdge (N9_0, N9_1) {
        value = "taskname"
    }
    MatchEdge (N9_1, N9_2) {
        value = "'frame'"
    }
    CreateEdge (N9_2, N9_12) {
        value = "'evalstack'"
    }
    DeleteEdge (N9_2, N9_13) {
        value = "'evalstack'"
    }
    DeleteEdge (N9_2, N9_14) {
        value = "'IP'"
    }
    CreateEdge (N9_2, N9_11) {
        value = "'phase'"
    }
    DeleteEdge (N9_2, N9_15) {
        value = "'phase'"
    }
    MatchEdge (N9_2, N9_10) {
        value = "'returnvalue'"
    }
    CreateEdge (N9_2, N9_17) {
        value = "'IP'"
    }
    CreateEdge (N9_3, N9_14) {
        value = "'caller'"
    }
    CreateEdge (N9_3, N9_2) {
        value = "'prev'"
    }
    CreateEdge (N9_3, N9_4) {
        value = "'phase'"
    }
    CreateEdge (N9_3, N9_5) {
        value = "'evalstack'"
    }
    CreateEdge (N9_3, N9_6) {
        value = "'symbols'"
    }
    CreateEdge (N9_3, N9_7) {
        value = "'returnvalue'"
    }
    CreateEdge (N9_3, N9_8) {
        value = "'IP'"
    }
    MatchEdge (N9_10, N9_9) {
        value = "'params'"
    }
    MatchEdge (N9_10, N9_8) {
        value = "'body'"
    }
    CreateEdge (N9_12, N9_13) {
        value = "'prev'"
    }
    CreateEdge (N9_13, N9_14) {
        value = "'inst'"
    }
    CreateEdge (N9_13, N9_16) {
        value = "'phase'"
    }
    MatchEdge (N9_14, N9_15) {
        value = "'params'"
    }
    MatchEdge (N9_15, N9_16) {
        value = "'next_param'"
    }
    MatchEdge (N9_15, N9_17) {
        value = "'value'"
    }
}

Rule Call_Params_First_Single_N10 {
    Root N10_0 {}
    Match N10_1 {
        match = True
    }
    Match N10_2 {
        match = True
    }
    Create N10_3 {}
    Create N10_4 {
        value = "'init'"
    }
    Create N10_5 {}
    Create N10_6 {}
    Create N10_7 {}
    Match N10_8 {}
    Create N10_9 {
        value = "'init'"
    }
    Match N10_10 {}
    Match N10_11 {}
    Match N10_12 {}
    Create N10_13 {
        value = "'call'"
    }
    Match N10_14 {
        value = "!call"
        match = True
    }
    Match N10_15 {
        match = True
    }
    Match N10_16 {}
    Create N10_17 {}

    MatchEdge (N10_0, N10_1) {
        value = "taskname"
    }
    MatchEdge (N10_1, N10_2) {
        value = "'frame'"
    }
    CreateEdge (N10_2, N10_16) {
        value = "'IP'"
    }
    CreateEdge (N10_2, N10_9) {
        value = "'phase'"
    }
    MatchEdge (N10_2, N10_10) {
        value = "'returnvalue'"
    }
    DeleteEdge (N10_2, N10_12) {
        value = "'evalstack'"
    }
    CreateEdge (N10_2, N10_17) {
        value = "'evalstack'"
    }
    DeleteEdge (N10_2, N10_14) {
        value = "'IP'"
    }
    DeleteEdge (N10_2, N10_15) {
        value = "'phase'"
    }
    CreateEdge (N10_3, N10_4) {
        value = "'phase'"
    }
    CreateEdge (N10_3, N10_5) {
        value = "'evalstack'"
    }
    CreateEdge (N10_3, N10_6) {
        value = "'symbols'"
    }
    CreateEdge (N10_3, N10_7) {
        value = "'returnvalue'"
    }
    CreateEdge (N10_3, N10_2) {
        value = "'prev'"
    }
    CreateEdge (N10_3, N10_8) {
        value = "'IP'"
    }
    CreateEdge (N10_3, N10_14) {
        value = "'caller'"
    }
    MatchEdge (N10_10, N10_8) {
        value = "'body'"
    }
    MatchEdge (N10_10, N10_11) {
        value = "'params'"
    }
    CreateEdge (N10_12, N10_13) {
        value = "'phase'"
    }
    CreateEdge (N10_12, N10_14) {
        value = "'inst'"
    }
    MatchEdge (N10_14, N10_15) {
        value = "'params'"
    }
    MatchEdge (N10_14, N10_15) {
        value = "'last_param'"
    }
    MatchEdge (N10_15, N10_16) {
        value = "'value'"
    }
    CreateEdge (N10_17, N10_12) {
        value = "'prev'"
    }
}

Rule Call_Params_Last_N11 {
    Root N11_0 {}
    Match N11_1 {
        match = True
    }
    Match N11_2 {
        match = True
    }
    Match N11_3 {}
    Match N11_4 {}
    Match N11_5 {}
    Match N11_6 {}
    Match N11_7 {}
    Create N11_9 {}
    Match N11_10 {}
    Match N11_11 {}
    Match N11_12 {
        value = "a"
    }
    Match N11_13 {}
    Match N11_14 {
        match = True
    }
    Create N11_15 {
        value = "'call'"
    }
    Match N11_16 {
        value = "!call"
        match = True
    }
    Match N11_17 {}
    Create N11_18 {}
    Create N11_19 {
        value = "'init'"
    }
    Match N11_20 {}

    MatchEdge (N11_0, N11_1) {
        value = "taskname"
    }
    MatchEdge (N11_1, N11_2) {
        value = "'frame'"
    }
    DeleteEdge (N11_2, N11_16) {
        value = "'IP'"
    }
    DeleteEdge (N11_2, N11_17) {
        value = "'evalstack'"
    }
    CreateEdge (N11_2, N11_18) {
        value = "'evalstack'"
    }
    CreateEdge (N11_2, N11_19) {
        value = "'phase'"
    }
    DeleteEdge (N11_2, N11_14) {
        value = "'phase'"
    }
    MatchEdge (N11_2, N11_10) {
        value = "'returnvalue'"
    }
    CreateEdge (N11_2, N11_13) {
        value = "'IP'"
    }
    MatchEdge (N11_3, N11_16) {
        value = "'caller'"
    }
    MatchEdge (N11_3, N11_2) {
        value = "'prev'"
    }
    MatchEdge (N11_3, N11_20) {
        value = "'symbols'"
    }
    MatchEdge (N11_3, N11_5) {
        value = "'IP'"
    }
    MatchEdge (N11_4, N11_5) {
        value = "'body'"
    }
    MatchEdge (N11_4, N11_6) {
        value = "'params'"
    }
    MatchEdge (N11_6, N11_7) {
        value = "a"
    }
    CreateEdge (N11_9, N11_10) {
        value = "'value'"
    }
    MatchEdge (N11_11, N11_14) {
        value = "'next_param'"
    }
    MatchEdge (N11_11, N11_12) {
        value = "'name'"
    }
    MatchEdge (N11_14, N11_13) {
        value = "'value'"
    }
    MatchEdge (N11_16, N11_14) {
        value = "'last_param'"
    }
    CreateEdge (N11_17, N11_16) {
        value = "'inst'"
    }
    CreateEdge (N11_17, N11_15) {
        value = "'phase'"
    }
    CreateEdge (N11_18, N11_17) {
        value = "'prev'"
    }
    CreateEdge N11_8 (N11_20, N11_9) {}
    CreateEdge (N11_8, N11_7) {}
}

Rule Call_Params_Next_N12 {
    Root N12_0 {}
    Match N12_1 {
        match = True
    }
    Match N12_2 {
        match = True
    }
    Match N12_3 {}
    Match N12_4 {}
    Match N12_5 {}
    Match N12_6 {}
    Match N12_7 {}
    Create N12_9 {}
    Match N12_10 {}
    Match N12_11 {
        match = True
    }
    Match N12_12 {}
    Match N12_13 {}
    Match N12_14 {
        value = "a"
    }
    Create N12_15 {}
    Match N12_16 {}
    Match N12_17 {}
    Match N12_18 {
        match = True
    }
    Match N12_19 {
        value = "!call"
        match = True
    }
    Create N12_20 {
        value = "'init'"
    }

    MatchEdge (N12_0, N12_1) {
        value = "taskname"
    }
    MatchEdge (N12_1, N12_2) {
        value = "'frame'"
    }
    MatchEdge (N12_2, N12_10) {
        value = "'returnvalue'"
    }
    DeleteEdge (N12_2, N12_11) {
        value = "'phase'"
    }
    DeleteEdge (N12_2, N12_17) {
        value = "'evalstack'"
    }
    CreateEdge (N12_2, N12_15) {
        value = "'evalstack'"
    }
    CreateEdge (N12_2, N12_16) {
        value = "'IP'"
    }
    DeleteEdge (N12_2, N12_19) {
        value = "'IP'"
    }
    CreateEdge (N12_2, N12_20) {
        value = "'phase'"
    }
    MatchEdge (N12_3, N12_5) {
        value = "'IP'"
    }
    MatchEdge (N12_3, N12_13) {
        value = "'symbols'"
    }
    MatchEdge (N12_3, N12_2) {
        value = "'prev'"
    }
    MatchEdge (N12_3, N12_19) {
        value = "'caller'"
    }
    MatchEdge (N12_4, N12_6) {
        value = "'params'"
    }
    MatchEdge (N12_4, N12_5) {
        value = "'body'"
    }
    MatchEdge (N12_6, N12_7) {
        value = "a"
    }
    CreateEdge (N12_9, N12_10) {
        value = "'value'"
    }
    MatchEdge (N12_11, N12_18) {
        value = "'next_param'"
    }
    MatchEdge (N12_11, N12_16) {
        value = "'value'"
    }
    MatchEdge (N12_12, N12_14) {
        value = "'name'"
    }
    MatchEdge (N12_12, N12_11) {
        value = "'next_param'"
    }
    CreateEdge (N12_15, N12_17) {
        value = "'prev'"
    }
    CreateEdge (N12_17, N12_18) {
        value = "'phase'"
    }
    CreateEdge (N12_17, N12_19) {
        value = "'inst'"
    }
    CreateEdge N12_8 (N12_13, N12_9) {}
    CreateEdge (N12_8, N12_7) {}
}

Rule Call_Resolve_No_Params_N13 {
    Root N13_0 {}
    Match N13_1 {
        match = True
    }
    Match N13_2 {
        match = True
    }
    Match N13_3 {
        value = "'init'"
        match = True
    }
    Create N13_4 {}
    Match N13_5 {}
    Match N13_6 {
        value = "!call"
        match = True
    }
    Create N13_7 {
        value = "'call'"
    }
    Match N13_8 {}
    NAC N13_9 {
        match = True
    }

    MatchEdge (N13_0, N13_1) {
        value = "taskname"
    }
    MatchEdge (N13_1, N13_2) {
        value = "'frame'"
    }
    DeleteEdge (N13_2, N13_6) {
        value = "'IP'"
    }
    MatchEdge (N13_2, N13_3) {
        value = "'phase'"
    }
    CreateEdge (N13_2, N13_4) {
        value = "'evalstack'"
    }
    DeleteEdge (N13_2, N13_5) {
        value = "'evalstack'"
    }
    CreateEdge (N13_2, N13_8) {
        value = "'IP'"
    }
    CreateEdge (N13_4, N13_5) {
        value = "'prev'"
    }
    CreateEdge (N13_5, N13_6) {
        value = "'inst'"
    }
    CreateEdge (N13_5, N13_7) {
        value = "'phase'"
    }
    NACEdge (N13_6, N13_9) {
        value = "'params'"
    }
    MatchEdge (N13_6, N13_8) {
        value = "'func'"
    }
}

Rule Call_Resolve_Params_N14 {
    Root N14_0 {}
    Match N14_1 {
        match = True
    }
    Match N14_2 {
        match = True
    }
    Match N14_3 {}
    Create N14_4 {}
    Match N14_5 {
        value = "!call"
        match = True
    }
    Match N14_6 {}
    Match N14_7 {
        value = "'init'"
        match = True
    }
    Match N14_8 {
        match = True
    }

    MatchEdge (N14_0, N14_1) {
        value = "taskname"
    }
    MatchEdge (N14_1, N14_2) {
        value = "'frame'"
    }
    DeleteEdge (N14_2, N14_3) {
        value = "'evalstack'"
    }
    CreateEdge (N14_2, N14_4) {
        value = "'evalstack'"
    }
    DeleteEdge (N14_2, N14_5) {
        value = "'IP'"
    }
    CreateEdge (N14_2, N14_6) {
        value = "'IP'"
    }
    MatchEdge (N14_2, N14_7) {
        value = "'phase'"
    }
    CreateEdge (N14_3, N14_8) {
        value = "'phase'"
    }
    CreateEdge (N14_3, N14_5) {
        value = "'inst'"
    }
    CreateEdge (N14_4, N14_3) {
        value = "'prev'"
    }
    MatchEdge (N14_5, N14_8) {
        value = "'params'"
    }
    MatchEdge (N14_5, N14_6) {
        value = "'func'"
    }
}

Rule Const_N15 {
    Root N15_0 {}
    Match N15_1 {
        match = True
    }
    Match N15_2 {
        match = True
    }
    Match N15_3 {}
    Match N15_4 {
        value = "'init'"
        match = True
    }
    Create N15_5 {
        value = "'finish'"
    }
    Match N15_6 {
        value = "!constant"
        match = True
    }
    Match N15_7 {}

    MatchEdge (N15_0, N15_1) {
        value = "taskname"
    }
    MatchEdge (N15_1, N15_2) {
        value = "'frame'"
    }
    CreateEdge (N15_2, N15_7) {
        value = "'returnvalue'"
    }
    DeleteEdge (N15_2, N15_3) {
        value = "'returnvalue'"
    }
    DeleteEdge (N15_2, N15_4) {
        value = "'phase'"
    }
    CreateEdge (N15_2, N15_5) {
        value = "'phase'"
    }
    MatchEdge (N15_2, N15_6) {
        value = "'IP'"
    }
    MatchEdge (N15_6, N15_7) {
        value = "'node'"
    }
}

Rule Continue_N16 {
    Root N16_0 {}
    Match N16_1 {
        match = True
    }
    Match N16_2 {
        match = True
    }
    Match N16_3 {
        value = "'init'"
        match = True
    }
    Match N16_4 {
        value = "!continue"
        match = True
    }
    Match N16_5 {
        value = "!while"
    }
    Match N16_6 {}
    Match N16_7 {}
    Create N16_8 {}
    Match N16_9 {}
    Create N16_10 {
        value = "'finish'"
    }

    MatchEdge (N16_0, N16_1) {
        value = "taskname"
    }
    MatchEdge (N16_1, N16_2) {
        value = "'frame'"
    }
    DeleteEdge (N16_2, N16_3) {
        value = "'phase'"
    }
    CreateEdge (N16_2, N16_10) {
        value = "'phase'"
    }
    MatchEdge (N16_2, N16_4) {
        value = "'IP'"
    }
    MatchEdge (N16_4, N16_5) {
        value = "'while'"
    }
    DeleteEdge (N16_2, N16_6) {
        value = "'evalstack'"
    }
    MatchEdge (N16_7, N16_5) {
        value = "taskname"
    }
    DeleteEdge (N16_9, N16_7) {
        value = "'prev'"
    }
    CreateEdge (N16_2, N16_8) {
        value = "'evalstack'"
    }
    CreateEdge (N16_8, N16_7) {
        value = "'prev'"
    }
}

Rule Declare_Init_N17 {
    Root N17_0 {}
    Match N17_1 {
        match = True
    }
    Match N17_2 {
        match = True
    }
    Match N17_3 {
        value = "'init'"
        match = True
    }
    Create N17_4 {
        value = "'finish'"
    }
    Match N17_5 {
        value = "!declare"
        match = True
    }
    Match N17_6 {}
    Match N17_7 {}
    Create N17_8 {}
    
    MatchEdge (N17_0, N17_1) {
        value = "taskname"
    }
    MatchEdge (N17_1, N17_2) {
        value = "'frame'"
    }
    DeleteEdge (N17_2, N17_3) {
        value = "'phase'"
    }
    CreateEdge (N17_2, N17_4) {
        value = "'phase'"
    }
    MatchEdge (N17_2, N17_5) {
        value = "'IP'"
    }
    MatchEdge (N17_2, N17_6) {
        value = "'symbols'"
    }
    MatchEdge (N17_5, N17_7) {
        value = "'var'"
    }
    CreateEdge N17_9 (N17_6, N17_8) {}
    CreateEdge (N17_9, N17_7) {}
}

Rule Global_Init_N18 {
    Root N18_0 {}
    Match N18_1 {
        match = True
    }
    Match N18_2 {
        match = True
    }
    Match N18_3 {}
    Match N18_4 {
        value = "'init'"
        match = True
    }
    Create N18_5 {
        value = "'finish'"
    }
    Match N18_6 {
        value = "!global"
        match = True
    }
    Match N18_7 {}
    Create N18_8 {}

    MatchEdge (N18_0, N18_1) {
        value = "taskname"
    }
    MatchEdge (N18_1, N18_2) {
        value = "'frame'"
    }
    MatchEdge (N18_1, N18_3) {
        value = "'globals'"
    }
    DeleteEdge (N18_2, N18_4) {
        value = "'phase'"
    }
    CreateEdge (N18_2, N18_5) {
        value = "'phase'"
    }
    MatchEdge (N18_2, N18_6) {
        value = "'IP'"
    }
    MatchEdge (N18_6, N18_7) {
        value = "'var'"
    }
    CreateEdge N18_9 (N18_3, N18_8) {}
    CreateEdge (N18_9, N18_7) {}
}

Rule If_Cond_N19 {
    Root N19_0 {}
    Match N19_1 {
        match = True
    }
    Match N19_2 {
        match = True
    }
    Match N19_3 {
        value = "'init'"
        match = True
    }
    Create N19_4 {}
    Match N19_5 {}
    Match N19_6 {
        value = "!if"
        match = True
    }
    Create N19_7 {
        value = "'cond'"
    }
    Match N19_8 {}

    MatchEdge (N19_0, N19_1) {
        value = "taskname"
    }
    MatchEdge (N19_1, N19_2) {
        value = "'frame'"
    }
    MatchEdge (N19_2, N19_3) {
        value = "'phase'"
    }
    DeleteEdge (N19_2, N19_6) {
        value = "'IP'"
    }
    CreateEdge (N19_2, N19_4) {
        value = "'evalstack'"
    }
    DeleteEdge (N19_2, N19_5) {
        value = "'evalstack'"
    }
    CreateEdge (N19_2, N19_8) {
        value = "'IP'"
    }
    CreateEdge (N19_4, N19_5) {
        value = "'prev'"
    }
    CreateEdge (N19_5, N19_6) {
        value = "'inst'"
    }
    CreateEdge (N19_5, N19_7) {
        value = "'phase'"
    }
    MatchEdge (N19_6, N19_8) {
        value = "'cond'"
    }
}

Rule If_False_Else_N20 {
    Root N20_0 {}
    Match N20_1 {
        match = True
    }
    Match N20_2 {
        match = True
    }
    Match N20_3 {
        value = "'cond'"
        match = True
    }
    Match N20_4 {
        value = "!if"
        match = True
    }
    Create N20_5 {}
    Match N20_6 {
        value = "False"
        match = True
    }
    Create N20_7 {
        value = "'init'"
    }
    Match N20_8 {
        match = True
    }
    Match N20_9 {}
    Create N20_10 {
        value = "'finish'"
    }

    MatchEdge (N20_0, N20_1) {
        value = "taskname"
    }
    MatchEdge (N20_1, N20_2) {
        value = "'frame'"
    }
    DeleteEdge (N20_2, N20_3) {
        value = "'phase'"
    }
    DeleteEdge (N20_2, N20_4) {
        value = "'IP'"
    }
    CreateEdge (N20_2, N20_5) {
        value = "'evalstack'"
    }
    MatchEdge (N20_2, N20_6) {
        value = "'returnvalue'"
    }
    CreateEdge (N20_2, N20_7) {
        value = "'phase'"
    }
    DeleteEdge (N20_2, N20_9) {
        value = "'evalstack'"
    }
    CreateEdge (N20_2, N20_8) {
        value = "'IP'"
    }
    MatchEdge (N20_4, N20_8) {
        value = "'else'"
    }
    CreateEdge (N20_5, N20_9) {
        value = "'prev'"
    }
    CreateEdge (N20_9, N20_4) {
        value = "'inst'"
    }
    CreateEdge (N20_9, N20_10) {
        value = "'phase'"
    }
}

Rule If_False_None_N21 {
    Root N21_0 {}
    Match N21_1 {
        match = True
    }
    Match N21_2 {
        match = True
    }
    Match N21_3 {
        value = "'cond'"
        match = True
    }
    Create N21_4 {
        value = "'finish'"
    }
    Match N21_5 {
        value = "!if"
        match = True
    }
    Match N21_6 {
        value = "False"
        match = True
    }
    NAC N21_7 {
        match = True
    }

    MatchEdge (N21_0, N21_1) {
        value = "taskname"
    }
    MatchEdge (N21_1, N21_2) {
        value = "'frame'"
    }
    MatchEdge (N21_2, N21_5) {
        value = "'IP'"
    }
    MatchEdge (N21_2, N21_6) {
        value = "'returnvalue'"
    }
    DeleteEdge (N21_2, N21_3) {
        value = "'phase'"
    }
    CreateEdge (N21_2, N21_4) {
        value = "'phase'"
    }
    NACEdge (N21_5, N21_7) {
        value = "'else'"
    }
}

Rule If_True_N22 {
    Root N22_0 {}
    Match N22_1 {
        match = True
    }
    Match N22_2 {
        match = True
    }
    Match N22_3 {
        value = "'cond'"
        match = True
    }
    Create N22_4 {}
    Create N22_5 {
        value = "'init'"
    }
    Match N22_6 {
        value = "True"
        match = True
    }
    Match N22_7 {}
    Match N22_8 {}
    Match N22_9 {
        value = "!if"
        match = True
    }
    Create N22_10 {
        value = "'finish'"
    }

    MatchEdge (N22_0, N22_1) {
        value = "taskname"
    }
    MatchEdge (N22_1, N22_2) {
        value = "'frame'"
    }
    DeleteEdge (N22_2, N22_3) {
        value = "'phase'"
    }
    DeleteEdge (N22_2, N22_9) {
        value = "'IP'"
    }
    CreateEdge (N22_2, N22_4) {
        value = "'evalstack'"
    }
    CreateEdge (N22_4, N22_7) {
        value = "'prev'"
    }
    CreateEdge (N22_2, N22_5) {
        value = "'phase'"
    }
    MatchEdge (N22_2, N22_6) {
        value = "'returnvalue'"
    }
    DeleteEdge (N22_2, N22_7) {
        value = "'evalstack'"
    }
    CreateEdge (N22_2, N22_8) {
        value = "'IP'"
    }
    CreateEdge (N22_7, N22_9) {
        value = "'inst'"
    }
    CreateEdge (N22_7, N22_10) {
        value = "'phase'"
    }
    MatchEdge (N22_9, N22_8) {
        value = "'then'"
    }
}

Rule Input_N23 {
    Root N23_0 {}
    Match N23_1 {
        match = True
    }
    Match N23_2 {
        match = True
    }
    Create N23_3 {
        value = "'finish'"
    }
    Match N23_4 {}
    Match N23_5 {
        value = "!input"
        match = True
    }
    Match N23_6 {
        value = "'init'"
        match = True
    }
    Match N23_7 {
        match = True
    }
    Match N23_8 {
        match = True
    }
    Match N23_9 {}

    MatchEdge (N23_0, N23_1) {
        value = "taskname"
    }
    MatchEdge (N23_1, N23_2) {
        value = "'frame'"
    }
    CreateEdge (N23_2, N23_3) {
        value = "'phase'"
    }
    DeleteEdge (N23_2, N23_4) {
        value = "'returnvalue'"
    }
    MatchEdge (N23_2, N23_5) {
        value = "'IP'"
    }
    DeleteEdge (N23_2, N23_6) {
        value = "'phase'"
    }
    CreateEdge (N23_2, N23_7) {
        value = "'returnvalue'"
    }
    DeleteEdge (N23_1, N23_8) {
        value = "'input'"
    }
    DeleteEdge (N23_8, N23_7) {
        value = "'value'"
    }
    DeleteEdge (N23_8, N23_9) {
        value = "'next'"
    }
    CreateEdge (N23_1, N23_9) {
        value = "'input'"
    }
}

Rule Next_Next_N24 {
    Root N24_0 {}
    Match N24_1 {
        match = True
    }
    Match N24_2 {
        match = True
    }
    Match N24_3 {
        value = "'finish'"
        match = True
    }
    Create N24_4 {
        value = "'init'"
    }
    Match N24_5 {
        match = True
    }
    Match N24_6 {
        match = True
    }

    MatchEdge (N24_0, N24_1) {
        value = "taskname"
    }
    MatchEdge (N24_1, N24_2) {
        value = "'frame'"
    }
    DeleteEdge (N24_2, N24_3) {
        value = "'phase'"
    }
    CreateEdge (N24_2, N24_4) {
        value = "'phase'"
    }
    DeleteEdge (N24_2, N24_5) {
        value = "'IP'"
    }
    CreateEdge (N24_2, N24_6) {
        value = "'IP'"
    }
    MatchEdge (N24_5, N24_6) {
        value = "'next'"
    }
}

Rule Next_NoNext_N25 {
    Root N25_0 {}
    Match N25_1 {
        match = True
    }
    Match N25_2 {
        match = True
    }
    Match N25_3 {
        value = "'finish'"
        match = True
    }
    Match N25_4 {
        match = True
    }
    Match N25_5 {}
    Match N25_6 {}
    Match N25_7 {}
    Match N25_8 {}
    NAC N25_9 {
        match = True
    }

    MatchEdge (N25_0, N25_1) {
        value = "taskname"
    }
    MatchEdge (N25_1, N25_2) {
        value = "'frame'"
    }
    DeleteEdge (N25_2, N25_3) {
        value = "'phase'"
    }
    DeleteEdge (N25_2, N25_4) {
        value = "'IP'"
    }
    CreateEdge (N25_2, N25_5) {
        value = "'IP'"
    }
    DeleteEdge (N25_2, N25_6) {
        value = "'evalstack'"
    }
    CreateEdge (N25_2, N25_7) {
        value = "'evalstack'"
    }
    CreateEdge (N25_2, N25_8) {
        value = "'phase'"
    }
    DeleteEdge (N25_6, N25_7) {
        value = "'prev'"
    }
    DeleteEdge (N25_7, N25_5) {
        value = "'inst'"
    }
    DeleteEdge (N25_7, N25_8) {
        value = "'phase'"
    }
    NACEdge (N25_4, N25_9) {
        value = "'next'"
    }
}

Rule Output_Init_N26 {
    Root N26_0 {}
    Match N26_1 {
        match = True
    }
    Match N26_2 {
        match = True
    }
    Match N26_3 {
        value = "'init'"
        match = True
    }
    Match N26_4 {
        value = "!output"
        match = True
    }
    Create N26_5 {}
    Match N26_6 {}
    Match N26_7 {}
    Create N26_8 {
        value = "'output'"
    }

    MatchEdge (N26_0, N26_1) {
        value = "taskname"
    }
    MatchEdge (N26_1, N26_2) {
        value = "'frame'"
    }
    MatchEdge (N26_2, N26_3) {
        value = "'phase'"
    }
    DeleteEdge (N26_2, N26_4) {
        value = "'IP'"
    }
    CreateEdge (N26_2, N26_5) {
        value = "'evalstack'"
    }
    CreateEdge (N26_5, N26_6) {
        value = "'prev'"
    }
    DeleteEdge (N26_2, N26_6) {
        value = "'evalstack'"
    }
    CreateEdge (N26_2, N26_7) {
        value = "'IP'"
    }
    CreateEdge (N26_6, N26_4) {
        value = "'inst'"
    }
    CreateEdge (N26_6, N26_8) {
        value = "'phase'"
    }
    MatchEdge (N26_4, N26_7) {
        value = "'value'"
    }
}

Rule Output_Output_N27 {
    Root N27_0 {}
    Match N27_1 {
        match = True
    }
    Match N27_2 {
        match = True
    }
    Match N27_3 {}
    Match N27_4 {
        value = "!output"
        match = True
    }
    Match N27_5 {
        value = "'output'"
        match = True
    }
    Create N27_6 {
        value = "'finish'"
    }
    Match N27_7 {}
    Create N27_8 {}

    MatchEdge (N27_0, N27_1) {
        value = "taskname"
    }
    MatchEdge (N27_1, N27_2) {
        value = "'frame'"
    }
    MatchEdge (N27_2, N27_4) {
        value = "'IP'"
    }
    DeleteEdge (N27_2, N27_5) {
        value = "'phase'"
    }
    CreateEdge (N27_2, N27_6) {
        value = "'phase'"
    }
    MatchEdge (N27_2, N27_7) {
        value = "'returnvalue'"
    }
    CreateEdge (N27_3, N27_7) {
        value = "'value'"
    }
    CreateEdge (N27_3, N27_8) {
        value = "'next'"
    }
    CreateEdge (N27_1, N27_8) {
        value = "'last_output'"
    }
    DeleteEdge (N27_1, N27_3) {
        value = "'last_output'"
    }
}

Rule Resolve_NoAttrGlobal_N28 {
    Root N28_0 {}
    Match N28_1 {
        match = True
    }
    Match N28_2 {}
    Match N28_3 {
        match = True
    }
    Create N28_4 {
        value = "'finish'"
    }
    Match N28_5 {
        match = True
    }
    Match N28_6 {}
    Match N28_7 {
        value = "!resolve"
        match = True
    }
    Match N28_8 {
        value = "'init'"
        match = True
    }
    Match N28_9 {}
    Match N28_10 {
        value = "a"
        match = True
    }
    NAC N28_11 {
        match = True
    }

    MatchEdge (N28_0, N28_1) {
        value = "taskname"
    }
    MatchEdge (N28_1, N28_2) {
        value = "'globals'"
    }
    MatchEdge (N28_1, N28_3) {
        value = "'frame'"
    }
    CreateEdge (N28_3, N28_4) {
        value = "'phase'"
    }
    MatchEdge (N28_3, N28_5) {
        value = "'symbols'"
    }
    DeleteEdge (N28_3, N28_6) {
        value = "'returnvalue'"
    }
    MatchEdge (N28_3, N28_7) {
        value = "'IP'"
    }
    DeleteEdge (N28_3, N28_8) {
        value = "'phase'"
    }
    CreateEdge (N28_3, N28_9) {
        value = "'returnvalue'"
    }
    MatchEdge (N28_2, N28_9) {
        value = "a"
    }
    MatchEdge (N28_7, N28_10) {
        value = "'var'"
    }
    NACEdge N28_12 (N28_5, N28_11) {}
    NACEdge (N28_12, N28_10) {}
}

Rule Resolve_NoAttr_N29 {
    Root N29_0 {}
    Match N29_1 {
        match = True
    }
    Match N29_2 {
        match = True
    }
    Match N29_3 {
        value = "!resolve"
        match = True
    }
    Match N29_4 {
        value = "'init'"
        match = True
    }
    Create N29_5 {
        value = "'finish'"
    }
    Match N29_6 {
        match = True
    }
    Match N29_7 {
        match = True
    }
    Match N29_8 {}
    Match N29_9 {
        match = True
    }

    MatchEdge (N29_0, N29_1) {
        value = "taskname"
    }
    MatchEdge (N29_1, N29_2) {
        value = "'frame'"
    }
    MatchEdge (N29_2, N29_3) {
        value = "'IP'"
    }
    DeleteEdge (N29_2, N29_4) {
        value = "'phase'"
    }
    CreateEdge (N29_2, N29_5) {
        value = "'phase'"
    }
    MatchEdge (N29_2, N29_6) {
        value = "'symbols'"
    }
    CreateEdge (N29_2, N29_7) {
        value = "'returnvalue'"
    }
    DeleteEdge (N29_2, N29_8) {
        value = "'returnvalue'"
    }
    MatchEdge (N29_3, N29_9) {
        value = "'var'"
    }
    MatchEdge N29_10 (N29_6, N29_7) {}
    MatchEdge (N29_10, N29_9) {}
}

Rule Return_Eval_N30 {
    Root N30_0 {}
    Match N30_1 {
        match = True
    }
    Match N30_2 {
        match = True
    }
    Match N30_3 {}
    Match N30_4 {
        value = "'eval'"
        match = True
    }
    Match N30_5 {
        value = "!return"
        match = True
    }
    Match N30_6 {}
    Match N30_7 {}

    MatchEdge (N30_0, N30_1) {
        value = "taskname"
    }
    DeleteEdge (N30_1, N30_2) {
        value = "'frame'"
    }
    CreateEdge (N30_1, N30_3) {
        value = "'frame'"
    }
    DeleteEdge (N30_2, N30_4) {
        value = "'phase'"
    }
    DeleteEdge (N30_2, N30_5) {
        value = "'IP'"
    }
    DeleteEdge (N30_2, N30_6) {
        value = "'returnvalue'"
    }
    DeleteEdge (N30_2, N30_3) {
        value = "'prev'"
    }
    CreateEdge (N30_3, N30_6) {
        value = "'returnvalue'"
    }
    DeleteEdge (N30_3, N30_7) {
        value = "'returnvalue'"
    }
}

Rule Return_NoValue_N31 {
    Root N31_0 {}
    Match N31_1 {
        match = True
    }
    Match N31_2 {
        match = True
    }
    Match N31_3 {}
    Match N31_4 {
        value = "'init'"
        match = True
    }
    Match N31_5 {
        value = "!return"
        match = True
    }
    NAC N31_6 {
        match = True
    }

    MatchEdge (N31_0, N31_1) {
        value = "taskname"
    }
    DeleteEdge (N31_1, N31_2) {
        value = "'frame'"
    }
    CreateEdge (N31_1, N31_3) {
        value = "'frame'"
    }
    DeleteEdge (N31_2, N31_4) {
        value = "'phase'"
    }
    DeleteEdge (N31_2, N31_5) {
        value = "'IP'"
    }
    DeleteEdge (N31_2, N31_3) {
        value = "'prev'"
    }
    NACEdge (N31_5, N31_6) {
        value = "'value'"
    }
}

Rule Return_Value_N32 {
    Root N32_0 {}
    Match N32_1 {
        match = True
    }
    Match N32_2 {
        match = True
    }
    Match N32_3 {
        value = "'init'"
        match = True
    }
    Create N32_4 {}
    Match N32_5 {
        value = "!return"
        match = True
    }
    Match N32_6 {}
    Match N32_7 {
        match = True
    }
    Create N32_8 {
        value = "'eval'"
    }

    MatchEdge (N32_0, N32_1) {
        value = "taskname"
    }
    MatchEdge (N32_1, N32_2) {
        value = "'frame'"
    }
    MatchEdge (N32_2, N32_3) {
        value = "'phase'"
    }
    DeleteEdge (N32_2, N32_5) {
        value = "'IP'"
    }
    CreateEdge (N32_2, N32_4) {
        value = "'evalstack'"
    }
    DeleteEdge (N32_2, N32_6) {
        value = "'evalstack'"
    }
    CreateEdge (N32_2, N32_7) {
        value = "'IP'"
    }
    CreateEdge (N32_4, N32_6) {
        value = "'prev'"
    }
    CreateEdge (N32_6, N32_5) {
        value = "'inst'"
    }
    CreateEdge (N32_6, N32_8) {
        value = "'phase'"
    }
    MatchEdge (N32_5, N32_7) {
        value = "'value'"
    }
}

Rule While_Cond_N33 {
    Root N33_0 {}
    Match N33_1 {
        match = True
    }
    Match N33_2 {
        match = True
    }
    Match N33_3 {
        value = "'init'"
        match = True
    }
    Create N33_4 {}
    Match N33_5 {
        value = "!while"
        match = True
    }
    Match N33_6 {}
    Match N33_7 {}
    Create N33_8 {
        value = "'cond'"
    }

    MatchEdge (N33_0, N33_1) {
        value = "taskname"
    }
    MatchEdge (N33_1, N33_2) {
        value = "'frame'"
    }
    MatchEdge (N33_2, N33_3) {
        value = "'phase'"
    }
    DeleteEdge (N33_2, N33_5) {
        value = "'IP'"
    }
    CreateEdge (N33_2, N33_4) {
        value = "'evalstack'"
    }
    DeleteEdge (N33_2, N33_6) {
        value = "'evalstack'"
    }
    CreateEdge (N33_2, N33_7) {
        value = "'IP'"
    }
    CreateEdge (N33_4, N33_6) {
        value = "'prev'"
    }
    CreateEdge (N33_6, N33_5) {
        value = "'inst'"
    }
    CreateEdge (N33_6, N33_8) {
        value = "'phase'"
    }
    MatchEdge (N33_5, N33_7) {
        value = "'cond'"
    }
}

Rule While_False_N34 {
    Root N34_0 {}
    Match N34_1 {
        match = True
    }
    Match N34_2 {
        match = True
    }
    Match N34_3 {
        value = "'cond'"
        match = True
    }
    Create N34_4 {
        value = "'finish'"
    }
    Match N34_5 {
        value = "!while"
        match = True
    }
    Match N34_6 {
        value = "False"
        match = True
    }

    MatchEdge (N34_0, N34_1) {
        value = "taskname"
    }
    MatchEdge (N34_1, N34_2) {
        value = "'frame'"
    }
    DeleteEdge (N34_2, N34_3) {
        value = "'phase'"
    }
    CreateEdge (N34_2, N34_4) {
        value = "'phase'"
    }
    MatchEdge (N34_2, N34_5) {
        value = "'IP'"
    }
    MatchEdge (N34_2, N34_6) {
        value = "'returnvalue'"
    }
}

Rule While_True_N35 {
    Root N35_0 {}
    Match N35_1 {
        match = True
    }
    Match N35_2 {
        match = True
    }
    Match N35_3 {
        value = "'cond'"
        match = True
    }
    Create N35_4 {
        value = "'init'"
    }
    Match N35_5 {
        value = "!while"
        match = True
    }
    Create N35_6 {}
    Match N35_7 {
        value = "True"
        match = True
    }
    Match N35_8 {}
    Match N35_9 {}
    Create N35_10 {
        value = "'init'"
    }
    Match N35_11 {}

    MatchEdge (N35_0, N35_1) {
        value = "taskname"
    }
    MatchEdge (N35_1, N35_2) {
        value = "'frame'"
    }
    DeleteEdge (N35_2, N35_3) {
        value = "'phase'"
    }
    CreateEdge (N35_2, N35_4) {
        value = "'phase'"
    }
    DeleteEdge (N35_2, N35_5) {
        value = "'IP'"
    }
    CreateEdge (N35_2, N35_6) {
        value = "'evalstack'"
    }
    MatchEdge (N35_2, N35_7) {
        value = "'returnvalue'"
    }
    DeleteEdge (N35_2, N35_8) {
        value = "'evalstack'"
    }
    CreateEdge (N35_2, N35_9) {
        value = "'IP'"
    }
    CreateEdge (N35_8, N35_5) {
        value = "'inst'"
    }
    CreateEdge (N35_8, N35_10) {
        value = "'phase'"
    }
    MatchEdge (N35_5, N35_9) {
        value = "'body'"
    }
    DeleteEdge (N35_8, N35_11) {
        value = "taskname"
    }
    CreateEdge (N35_8, N35_5) {
        value = "taskname"
    }
    CreateEdge (N35_6, N35_8) {
        value = "'prev'"
    }
}
