anchor.diff:    |> Async.Parallel
     |> Async.RunSynchronously
   
  +let module' = LLVM.ModuleCreateWithName(JitName)
  +let builder = LLVM.CreateBuilder()
  +let engine = ref (LLVMExecutionEngineRef(IntPtr.Zero))
   
   [<EntryPoint>]
   let main _ = 
     do 
  -    let module' = LLVM.ModuleCreateWithName(``my-cool-jit``)
  -    let builder = LLVM.CreateBuilder()
  -
  -    (* Run the main "interpreter loop" now. *)
  -    tests () |> ignore
  -    Driver.run Console.In
  -    LLVM.DumpModule(module')
  -  0+    LLVM.LinkInMCJIT()
  +    LLVM.InitializeX86TargetInfo()
  +    LLVM.InitializeX86Target()
  +    LLVM.InitializeX86TargetMC()
  +  let mutable message = ""
  +  if 1 = (LLVM.CreateExecutionEngineForModule(engine, module', &message)).Value 
  +    then 
  +      printfn "%s" message
  +      1
  +    else
  +      let passManager = LLVM.CreateFunctionPassManagerForModule(module')
  +      // Provide basic AliasAnalysis support for GVN.
  +      LLVM.AddBasicAliasAnalysisPass(passManager)
  +
  +      // Promote allocas to registers.
  +      LLVM.AddPromoteMemoryToRegisterPass(passManager)
  +
  +      // Do simple "peephole" optimizations and bit-twiddling optzns.
  +      LLVM.AddInstructionCombiningPass(passManager)
  +
  +      // Reassociate expressions.
  +      LLVM.AddReassociatePass(passManager)
  +
  +      // Eliminate Common SubExpressions.
  +      LLVM.AddGVNPass(passManager)
  +
  +      // Simplify the control flow graph (deleting unreachable blocks, etc).
  +      LLVM.AddCFGSimplificationPass(passManager)
  +
  +      ignore <| LLVM.InitializeFunctionPassManager(passManager)
  +      (* Run the main "interpreter loop" now. *)
  +      ignore <| tests ()
  +      Driver.run(Console.In)
  +      LLVM.DumpModule(module')
  +      LLVM.DisposeModule(module')
  +      LLVM.DisposeExecutionEngine(!engine)
  +      LLVM.DisposePassManager(passManager)
  +      0
  
positive.code:         do 
            printf "%s" prompt
            let lines = readLines scanner
            if String.IsNullOrWhiteSpace(lines)
              then runRepl ()
            let result = Parser.run lines
            Parser.showResult result
            runRepl ()
  
negative.code:       match decl with
        | Prototype (name, args) -> prototypeToString (name, args)
        | Function (prototype, body) ->
          sprintf "%s %O" (prototypeToString prototype) body
  
  module Lexer =
    open FParsec
  