anchor.diff:                          p1.Invoke ctxt)
   
   
  -        // callA = "bindA (return x) f"
  -        let callA f x =
  +        // Call the given function with exception protection, but first 
  +        // check for cancellation.
  +        let CreateCallAsync f x =
               MakeAsync (fun ctxt ->
                   if ctxt.aux.token.IsCancellationRequested then
                       ctxt.OnCancellation ()
  
positive.code:                     // The cancellation continuation runs the finallyFunction and then runs the previous cancellation continuation.
                      // If an exception is thrown we continue with the previous cancellation continuation (the exception is lost)
                      let ccont cexn = protectUserCodeIncludingHijackCheck trampolineHolder finallyFunction () (fun _ -> ctxt.aux.ccont cexn) (fun () -> ctxt.aux.ccont cexn)
                      p.Invoke { ctxt with cont = cont; aux = { ctxt.aux with econt = econt; ccont = ccont } })
  
          // Re-route the exception continuation to call to catchFunction. If catchFunction or the new process fail
          // then call the original exception continuation with the failure.
          let tryWithDispatchInfoA catchFunction computation =
              MakeAsync (fun ctxt ->
                  if ctxt.aux.token.IsCancellationRequested then
                      ctxt.OnCancellation ()
                  else 
                      let econt (edi: ExceptionDispatchInfo) = 
                          let ecomputation = callA catchFunction edi
                          ecomputation.Invoke ctxt
                      let newCtxt = { ctxt with aux = { ctxt.aux with econt = econt } }
                      computation.Invoke newCtxt)
  
          let tryWithExnA catchFunction computation = 
              computation |> tryWithDispatchInfoA (fun edi -> catchFunction (edi.GetAssociatedSourceException()))
  
          /// Call the finallyFunction if the computation results in a cancellation
          let whenCancelledA (finallyFunction : OperationCanceledException -> unit) computation =
              MakeAsync (fun ctxt ->
                  let aux = ctxt.aux
                  let ccont exn = protectUserCodeIncludingHijackCheck aux.trampolineHolder finallyFunction exn (fun _ -> aux.ccont exn) (fun _ -> aux.ccont exn)
  
negative.code:         
          /// A single pre-allocated computation that returns a unit result
          let unitAsync =
              CreateReturnAsync()
  
          /// Implement use/Dispose
          let CreateUsingAsync (resource:'T :> IDisposable) (computation:'T -> Async<'a>) : Async<'a> =
              let mutable x = 0
              let disposeFunction _ =
                  if Interlocked.CompareExchange(&x, 1, 0) = 0 then
                      Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicFunctions.Dispose resource
              CreateTryFinallyAsync disposeFunction (CreateCallAsync computation resource) |> CreateWhenCancelledAsync disposeFunction
  
          let CreateIgnoreAsync computation = 
              CreateBindAsync computation (fun _ -> unitAsync)
  
          /// Implement the while loop construct of async commputation expressions
          let rec CreateWhileAsync guardFunc computation =
              if guardFunc() then 
                  CreateBindAsync computation (fun () -> CreateWhileAsync guardFunc computation) 
              else 
                  unitAsync
  
          /// Implement the for loop construct of async commputation expressions
          let rec CreateForLoopAsync (source: seq<_>) computation =
              CreateUsingAsync (source.GetEnumerator()) (fun ie ->
                  CreateWhileAsync
                      (fun () -> ie.MoveNext())
                      (CreateDelayAsync (fun () -> computation ie.Current)))
  
          let CreateSwitchToAsync (syncCtxt: SynchronizationContext) =
              CreateUserCodeAsync (fun ctxt ->
                  ctxt.aux.trampolineHolder.Post syncCtxt ctxt.cont)
  
          let CreateSwitchToNewThreadAsync() =
              CreateUserCodeAsync (fun ctxt ->
                  ctxt.aux.trampolineHolder.StartThread ctxt.cont)
  
          let CreateSwitchToThreadPoolAsync() =
              CreateUserCodeAsync (fun ctxt -> 
                  ctxt.aux.trampolineHolder.QueueWorkItem ctxt.cont)
  
          let delimitSyncContext ctxt =            
              match SynchronizationContext.Current with
              | null -> ctxt
              | syncCtxt -> 
                  let aux = ctxt.aux                
  