anchor.diff:                          | _ -> ()  ]
   
   
  +            let results = ResizeArray()
               let searchPaths = 
                 [ yield! targetFrameworkDirectories 
                   yield! explicitIncludeDirs 
  
positive.code:                 if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then 
                      yield! registrySearchPaths() ]
  
              [| for (baggage,r) in references do
                  let mutable found = false
                  let success path = 
                      if not found then 
                          found <- true
                          [ { itemSpec = path; prepareToolTip = snd; baggage=baggage } ] 
                      else []
                  if Path.IsPathRooted(r) then 
                      if FileSystem.SafeExists(r) then 
                          yield! success r
                  else
                      let isFileName = 
                          r.EndsWith("dll",StringComparison.InvariantCultureIgnoreCase) ||
                          r.EndsWith("exe",StringComparison.InvariantCultureIgnoreCase)  
  
                      let qual = if isFileName then r else try AssemblyName(r).Name + ".dll"  with _ -> r + ".dll"
  
                      for searchPath in searchPaths do 
                          if not found then 
                              let trialPath = Path.Combine(searchPath,qual)
                              if FileSystem.SafeExists(trialPath) then 
                                  yield! success trialPath
                      if not found then 
                          let ass = try Some (System.Reflection.Assembly.ReflectionOnlyLoad(r)) with _ -> None
                          match ass with 
                          | None -> ()
                          | Some ass -> yield! success ass.Location |] }
  
  #if INTERACTIVE
  SimplisticResolver.DotNetFrameworkReferenceAssembliesRootDirectory
  
negative.code: #endif
  
  let GetDefaultResolver(msbuildEnabled: bool, msbuildVersion: string option) = 
      let msbuildEnabled = msbuildEnabled && false
      let tryMSBuild v = 
        if msbuildEnabled then 
          // Detect if MSBuild v12 is on the machine, if so use the resolver from there
          let mb = try Assembly.Load(sprintf "Microsoft.Build.Framework, Version=%s.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" v) |> Option.ofObj with _ -> None
          let ass = mb |> Option.bind (fun _ -> try Assembly.Load(sprintf "FSharp.Compiler.Service.MSBuild.v%s" v) |> Option.ofObj with _ -> None)
          let ty = ass |> Option.bind (fun ass -> ass.GetType("Microsoft.FSharp.Compiler.MSBuildReferenceResolver") |> Option.ofObj)
          let obj = ty |> Option.bind (fun ty -> ty.InvokeMember("get_Resolver",BindingFlags.Static ||| BindingFlags.Public ||| BindingFlags.InvokeMethod ||| BindingFlags.NonPublic, null, null, [| |]) |> Option.ofObj)
          let resolver = obj |> Option.bind (fun obj -> match obj with :? Resolver as r -> Some r | _ -> None)
          resolver
        else None
  