anchor.diff:          
           static let unfake FakeUnit = ()
   
  -        // Preallocate a ctxt-switching callback delegate.
  +        // Preallocate a context-switching callback delegate.
           // This should be the only call to SynchronizationContext.Post in this library. We must always install a trampoline.        
           let sendOrPostCallback = 
               SendOrPostCallback (fun o ->
                   let f = unbox<(unit -> AsyncReturn)> o
  -                this.ExecuteWithTrampoline f |> unfake)
  +                this.Execute f |> unfake)
   
           // Preallocate a ctxt-switching callback delegate.
           // This should be the only call to QueueUserWorkItem in this library. We must always install a trampoline.
           let waitCallbackForQueueWorkItemWithTrampoline = 
               WaitCallback (fun o ->
                   let f = unbox<(unit -> AsyncReturn)> o
  -                this.ExecuteWithTrampoline f |> unfake)
  +                this.Execute f |> unfake)
   
   #if !FX_NO_PARAMETERIZED_THREAD_START
           // This should be the only call to Thread.Start in this library. We must always install a trampoline.
           let threadStartCallbackForStartThreadWithTrampoline = 
               ParameterizedThreadStart (fun o ->
                   let f = unbox<(unit -> AsyncReturn)> o
  -                this.ExecuteWithTrampoline f |> unfake)
  +                this.Execute f |> unfake)
   #endif
   
           member this.Post (syncCtxt: SynchronizationContext)  (f : unit -> AsyncReturn) =
  
positive.code:                             match result with
                              | Some _ -> 
                                  if Interlocked.Increment exnCount = 1 then
                                      innerCts.Cancel(); trampolineHolder.ExecuteWithTrampoline (fun () -> ctxtWithSync.cont result)
                                  else
                                      FakeUnit
  
                              | None ->
                                  if Interlocked.Increment noneCount = computations.Length then
                                      innerCts.Cancel(); trampolineHolder.ExecuteWithTrampoline (fun () -> ctxtWithSync.cont None)
                                  else
                                      FakeUnit
   
                          let econt (exn : ExceptionDispatchInfo) =
                              if Interlocked.Increment exnCount = 1 then 
                                  innerCts.Cancel(); trampolineHolder.ExecuteWithTrampoline (fun () -> ctxtWithSync.aux.econt exn)
                              else
                                  FakeUnit
   
                          let ccont (exn : OperationCanceledException) =
                              if Interlocked.Increment exnCount = 1 then
                                  innerCts.Cancel(); trampolineHolder.ExecuteWithTrampoline (fun () -> ctxtWithSync.aux.ccont exn)
                              else
                                  FakeUnit
  
  
negative.code: 
              member __.ContinueImmediate res = 
                  let action () = ctxt.cont res
                  let inline executeImmediately () = trampolineHolder.Execute action
                  let currentSyncCtxt = SynchronizationContext.Current 
                  match syncCtxt, currentSyncCtxt with
                  | null, null -> 
  