anchor.diff:  
                       match contToTailCall with
                       | Some k -> k()
  -                    | _ -> Unchecked.defaultof<AsyncReturn>)
  +                    | _ -> fake())
                   
           static member DefaultCancellationToken = defaultCancellationTokenSource.Token
   
  
positive.code:             
          member this.PostWithTrampoline (syncCtxt: SynchronizationContext)  (f : unit -> AsyncReturn) =
              syncCtxt.Post (sendOrPostCallbackWithTrampoline, state=(f |> box))
              Unchecked.defaultof<AsyncReturn>
  
          member this.QueueWorkItemWithTrampoline (f: unit -> AsyncReturn) =            
              if not (ThreadPool.QueueUserWorkItem(waitCallbackForQueueWorkItemWithTrampoline, f |> box)) then
                  failwith "failed to queue user work item"
              Unchecked.defaultof<AsyncReturn>
  
          member this.PostOrQueueWithTrampoline (syncCtxt : SynchronizationContext) f =
              match syncCtxt with 
  
negative.code:         static member Create cancellationToken trampolineHolder cont econt ccont : AsyncActivation<'T> =
              AsyncActivation { cont = cont; aux = { token = cancellationToken; econt = econt; ccont = ccont; trampolineHolder = trampolineHolder } }
                      
          /// Queue the success continuation of the asynchronous execution context as a work item in the thread pool
          /// after installing a trampoline
          member ctxt.QueueContinuationWithTrampoline (result: 'T) =            
              let ctxt = ctxt
              ctxt.aux.trampolineHolder.QueueWorkItemWithTrampoline(fun () -> ctxt.cont result)
  
          /// Call the success continuation of the asynchronous execution context
          member ctxt.CallContinuation(result: 'T) =            
              ctxt.cont result
  
      /// Represents an asynchronous computation
      [<NoEquality; NoComparison; CompiledName("FSharpAsync`1")>]
      type Async<'T> =
          { Invoke : (AsyncActivation<'T> -> AsyncReturn) }
  
      /// Mutable register to help ensure that code is only executed once
      [<Sealed>]
      type Latch() = 
          let mutable i = 0
  
          /// Execute the latch
          member this.Enter() = Interlocked.CompareExchange(&i, 1, 0) = 0
  
      /// Ensures that a function is only called once
      [<Sealed>]
      type Once() =
          let latch = Latch()
  
          /// Execute the function at most once
          member this.Do f =
              if latch.Enter() then
                  f()
  
      /// Represents the result of an asynchronous computation
      [<NoEquality; NoComparison>]
      type AsyncResult<'T>  =
          | Ok of 'T
          | Error of ExceptionDispatchInfo
          | Canceled of OperationCanceledException
  
          /// Get the result of an asynchronous computation 
          [<DebuggerHidden>]
          member res.Commit () =
              match res with
  