let work tree (x::tail) =
    let unusedEdges tr nodeid = let node = findnode nodeid tr
                                in let out_edges = edgefilter tree (fun _ x1 -> let (c,_,_) =x1.edge in c.sourceid == nodeid)
                                in let targets = List.map (fun x1-> let (_,t,_) = x1.edge in t) out_edges
                                in let new_out_edges = List.filter (fun x1 -> not (List.mem x1 node.children )) targets
                                in let rec unused_edges child_list =
                                  match child_list with
                                    x1::t -> if has_edge_id nodeid x1 tr
                                            then 
                                              let edge_id = find_edge_id nodeid x1 tr
                                              in let edge = findedge edge_id tr
                                              in if edge.used 
                                                then unused_edges t
                                                else [edge]
                                            else unused_edges t
                                  | _ -> []
                                in unused_edges (List.concat [node.children;new_out_edges])
    in let xn = findnode x tree
    in let tt = if xn.number == NodeNumber.invalid_num then (markedNode tree xn) else tree
    in
    match (unusedEdges tt x) with
      y::t -> let (c,endnodeid,p) = y.edge 
                  in let endnode = findnode endnodeid tt
                  in if endnode.number == NodeNumber.invalid_num then (usedEdge (markedNode tt endnode) y Normal, endnodeid::x::tail) 
                    else if endnode.number > xn.number then (usedEdge tt y Forward, x::tail)
                      else if (endnode.number <= xn.number && endnode.allDone) then (usedEdge tt y Cross, x::tail)
                        else (usedEdge tt y Backward, x::tail)
    | _ -> (usedNode tt xn, tail)