anchor.diff:          Runtime.Remoting.RemotingServices.Disconnect logw |> ignore
           AppDomain.Unload(ad)
       #else
  -    let alc = FarkleAwareAssemblyLoadContext(path, references, log) :> AssemblyLoadContext
  +    let alc = FarkleAwareAssemblyLoadContext(path, references, log)
       try
  -        let asm = alc.LoadFromAssemblyPath path
  -        dynamicDiscoverAndPrecompile asm logw, WeakReference(alc)
  +        let asm = alc.TheAssembly
  +        if asm.GetName().Name = typeof<DesigntimeFarkle>.Assembly.GetName().Name then
  +            log.Error("Cannot precompile an assembly named 'Farkle'")
  +            []
  +        else
  +            dynamicDiscoverAndPrecompile asm logw
  +        , WeakReference(alc)
       finally
           alc.Unload()
           log.Verbose("The context is at generation {Generation}", GC.GetGeneration(alc))
  
positive.code:         let asm = Assembly.LoadFile path
          dynamicDiscoverAndPrecompile asm log
  
  let getAssemblyName (path: string) = AssemblyDefinition.ReadAssembly(path).Name.Name
  
  #if NET472
  let makeResolver references =
      let dict =
          references
          |> Seq.map (fun path -> KeyValuePair(getAssemblyName path, path))
          |> ImmutableDictionary.CreateRange
      ResolveEventHandler(fun _ e ->
          match e.Name with
          | "Farkle" -> null
  
negative.code: #else
  open System.Runtime.Loader
  
  type private FarkleAwareAssemblyLoadContext(path, references: string seq, log: ILogger) as this =
      inherit AssemblyLoadContext(sprintf "Farkle.Tools precompiler for %s" path, true)
      let dict =
          references
          |> Seq.choose (fun path ->
              use asm = AssemblyDefinition.ReadAssembly(path)
              if isReferenceAssembly asm then
                  None
              else
                  log.Debug("Using reference from {AssemblyPath}", path)
                  Some (asm.Name.Name, path))
          |> readOnlyDict
      let asm =
          let bytes = File.ReadAllBytes path
          let m = new MemoryStream(bytes, true)
          this.LoadFromStream m
      member _.TheAssembly = asm
      override this.Load(name) =
          log.Verbose("Requesting assembly {AssemblyName}", name)
          match name.Name with
          | "Farkle" -> typeof<DesigntimeFarkle>.Assembly
          | "FSharp.Core" -> typeof<FuncConvert>.Assembly
          | "mscorlib" | "System.Private.CoreLib"
          | "System.Runtime" | "netstandard" -> null
          | name ->
              match dict.TryGetValue name with
              | true, path ->
                  log.Verbose("Loading assembly from {AssemblyPath}", path)
                  this.LoadFromAssemblyPath path
              | false, _ -> null
  
  let private ensureUnloaded (log: ILogger) (wr: WeakReference) =
  