anchor.diff:  let private withDependencyType (depType:DependencyType) targets =
       targets |> List.map (fun t -> depType, t)
   
  -// Helper function for visiting targets in a dependency tree 
  +// Helper function for visiting targets in a dependency tree. Retutrns a set containing the names of the all the 
  +// visited targets, and a list containing the targets visited ordered such that dependencies of a target appear earlier
  +// in the list than the target.
   let private visitDependencies fVisit targetName = 
       let visit fGetDependencies fVisit targetName = 
           let visited = new HashSet<_>()
  
positive.code:     // First pass is to accumulate targets in (hard) dependency graph 
      let visited, _ = visit (fun t -> t.Dependencies |> withDependencyType DependencyType.Hard) (fun _ -> ()) targetName
   
      let getDependencies (t: TargetTemplate<unit>) = 
          if visited.Contains t.Name then
              (t.Dependencies |> withDependencyType DependencyType.Hard) @ 
              (t.SoftDependencies |> List.filter visited.Contains |> withDependencyType DependencyType.Soft)
          else 
              t.Dependencies |> withDependencyType DependencyType.Hard 
  
      // Now make second pass, adding in soft depencencies if approrpriate
      visit getDependencies fVisit targetName
      
                
  /// <summary>Writes a dependency graph.</summary>
  /// <param name="verbose">Whether to print verbose output or not.</param>
  /// <param name="target">The target for which the dependencies should be printed.</param>
  
negative.code:         let parallelJobs = environVarOrDefault "parallel-jobs" "1" |> int
  
          // Figure out the order in in which targets can be run, and which can be run in parallel.
          if parallelJobs > 1 then
              tracefn "Running parallel build with %d workers" parallelJobs
  
              // determine a parallel build order
              let order = determineBuildOrder targetName
              
              // run every level in parallel
              for par in order do
                  runTargetsParallel parallelJobs par
  
          else
              // single threaded build.
              PrintDependencyGraph false targetName
  
              // Note: we could use the ordering resulting from flattening the result of determineBuildOrder
              // for a single threaded build (thereby centralizing the algorithm for build order), but that
              // ordering is inconsistent with earlier versions of FAKE (and PrintDependencyGraph).
              let _, ordered = visitDependencies ignore targetName
              runTargets (ordered |> Seq.map getTarget |> Seq.toArray)
  
      finally
          if errors <> [] then
  