anchor.diff:  
   module internal Microsoft.FSharp.Compiler.CommandLineMain
   
  -open System.IO
  -open System.Text
  -open System.Reflection
   open Microsoft.FSharp.Compiler
   open Microsoft.FSharp.Compiler.AbstractIL.IL // runningOnMono 
  -open Microsoft.FSharp.Compiler.AbstractIL.Internal.Library 
  +open Microsoft.FSharp.Compiler.AbstractIL.Internal.Library
   open Microsoft.FSharp.Compiler.ErrorLogger
   open Microsoft.FSharp.Compiler.Driver
   open Internal.Utilities
  
positive.code:             | None -> 
                  None
  
  
  let runMain argv = 
      let inline hasArgument name args = 
          args |> Array.exists (fun x -> x = ("--" + name) || x = ("/" + name))
      let inline stripArgument name args = 
          args |> Array.filter (fun x -> x <> ("--" + name) && x <> ("/" + name))
  
      // Check for --pause as the very first step so that a compiler can be attached here.
      if hasArgument "pause" argv then 
          System.Console.WriteLine("Press any key to continue...")
          System.Console.ReadKey() |> ignore
        
      if runningOnMono && hasArgument "resident" argv then 
          let argv = stripArgument "resident" argv
  
          if not (hasArgument "nologo" argv) then 
              printfn "%s" (FSComp.SR.buildProductName(FSharpEnvironment.FSharpTeamVersionNumber))
              printfn "%s" (FSComp.SR.optsCopyright())
  
          let fscServerExe = typeof<TypeInThisAssembly>.Assembly.Location
          let exitCodeOpt = FSharpResidentCompiler.FSharpCompilationServer.TryCompileUsingServer (fscServerExe, argv)
          match exitCodeOpt with 
          | Some exitCode -> exitCode
          | None -> 
              mainCompile (argv, true, QuitProcessExiter, None)
              0
  
      elif runningOnMono && hasArgument "server" argv then 
          // Install the right exiter so we can catch "StopProcessing" without exiting the server
          let exiter = { new Exiter with member x.Exit n = raise StopProcessing }
          FSharpResidentCompiler.FSharpCompilationServer.RunServer(exiter)        
          0
          
      else
          mainCompile (argv, false, QuitProcessExiter, None)
          0
  
  
  [<EntryPoint>]
  let main(argv) =
  
negative.code: 
  type TypeInThisAssembly() = member x.Dummy = 1
  
  /// Implement the optional resident compilation service
  module FSharpResidentCompiler = 
  
      open System
      open System.Diagnostics
      open System.IO
      open System.Reflection
      open System.Runtime.Remoting.Channels
      open System.Runtime.Remoting
      open System.Runtime.Remoting.Lifetime
      open System.Text
  
      /// Collect the output from the stdout and stderr streams, character by character,
      /// recording the console color used along the way.
      type private OutputCollector() = 
          let output = ResizeArray()
          let outWriter isOut = 
              { new TextWriter() with 
                   member x.Write(c:char) = lock output (fun () -> output.Add (isOut, (try Some System.Console.ForegroundColor with _ -> None) ,c)) 
                   member x.Encoding = Encoding.UTF8 }
          member x.GetTextAndClear() = lock output (fun () -> let res = output.ToArray() in output.Clear(); res)
  
      /// The compilation server, which runs in the server process. Accessed by clients using .NET remoting.
      type FSharpCompilationServer(exiter:Exiter)  =
  