anchor.diff:  type WhyOptions = 
       { AllPaths : bool }
   
  -type WhyPath = list<PackageName * bool>
  -
  -type DependencyChain = Set<PackageName>
  +type DependencyChain = List<PackageName>
   
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module DependencyChain =
  
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: // e.g. Microsoft.AspNet.Mvc - not specified in paket.dependencies, a dependency of other package(s)
  | Transient of DependencyChain list
  
  type InferError =
  | NuGetNotInLockFile
  | NuGetNotInGroup of groupsHavingNuGet : GroupName list
  
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Reason =
      let format = function
      | TopLevel -> 
          sprintf "direct (%s) and top-level dependency." 
                  Constants.DependenciesFileName
      | Direct chains -> 
          sprintf "direct (%s) dependency."
                  Constants.DependenciesFileName
      | Transient chains -> 
          sprintf "transient dependency."
  
      let infer (packageName : PackageName, 
                 groupName : GroupName,
                 directDeps : Set<PackageName>, 
                 lockFile : LockFile) :
                 Result<Reason, InferError> =
          let group = lockFile.GetGroup groupName
          if not <| group.Resolution.ContainsKey packageName then
              let otherGroups =
                  lockFile.Groups 
                  |> Seq.filter (fun pair -> pair.Value.Resolution.ContainsKey packageName) 
                  |> Seq.map (fun pair -> pair.Key)
                  |> Seq.toList
              if List.isEmpty otherGroups then
                  Result.Bad [NuGetNotInLockFile]
              else
                  Result.Bad [NuGetNotInGroup otherGroups]
          else
              let graph = depGraph group.Resolution
              let topLevelDeps = 
                  lockFile.GetTopLevelDependencies groupName
                  |> Seq.map (fun pair -> pair.Key)
                  |> Set.ofSeq
              let chains = 
                  topLevelDeps
                  |> Set.toList
                  |> List.collect (fun p -> paths p packageName graph)
              match Set.contains packageName directDeps, Set.contains packageName topLevelDeps with
              | true, true ->
                  Result.Succeed TopLevel
              | true, false ->
                  Result.Succeed (Direct chains)
              | false, false ->
                  Result.Succeed (Transient chains)
              | false, true ->
                  failwith "impossible"
  
  let ohWhy (packageName, 
             directDeps : Set<PackageName>, 
  