anchor.diff:  
   open Paket.Domain
   open Paket.Logging
  +
  +open Chessie.ErrorHandling
   
   type AdjGraph<'a> = list<'a * list<'a>>
   
  
positive.code:            usage, 
             options) =
  
      let group = lockFile.GetGroup(groupName)
      if not <| group.Resolution.ContainsKey packageName then
          match lockFile.Groups |> Seq.filter (fun g -> g.Value.Resolution.ContainsKey packageName) |> Seq.toList with
          | _ :: _ as otherGroups ->
              traceWarnfn 
                  "NuGet %O was not found in %s group. However it was found in following groups: %A. Specify correct group." 
                  packageName
                  (groupName.ToString())
                  (otherGroups |> List.map (fun pair -> pair.Key.ToString()))
  
              usage |> traceWarn
          | [] ->
              traceErrorfn "NuGet %O was not found in %s" packageName Constants.LockFileName
      else
          let g = depGraph group.Resolution
          let topLevel = lockFile.GetTopLevelDependencies groupName
          let topLevelPaths = 
              topLevel
              |> Seq.map (fun pair -> pair.Key)
              |> Seq.toList
              |> List.collect (fun p -> paths p packageName g)
              |> List.map (List.map (fun name -> name, Set.contains name directDeps))
              |> List.groupBy (List.item 0)
  
          tracefn "Dependency paths for %O in group %s:" packageName (groupName.ToString())
          tracen ""
  
          for ((top,_), paths) in topLevelPaths do
              match paths |> List.sortBy List.length with
              | shortest :: rest ->
                  prettyPrintPath shortest
  
                  match rest, options.AllPaths with
                  | _ :: _, false ->
                      tracefn 
                          "... and %d path%s more starting at %O. To display all paths use --allpaths flag" 
                          rest.Length 
                          (if rest.Length > 1 then "s" else "") 
                          top
                      tracen ""
                  | _ :: _, true ->
                      List.iter prettyPrintPath rest
                  | [], _ ->
                      ()
  
              | [] ->
                  failwith "impossible"
negative.code: type WhyOptions = 
      { AllPaths : bool }
  
  type DependencyChain = List<PackageName>
  
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module DependencyChain =
  