anchor.diff:                                          | Choice2Of2 exn -> 
                                               return! 
                                                 (x.Dispose()
  -                                               state := 2
  +                                               state := TryWithState.PreHandler
                                                  enum := (handler exn).GetEnumerator()
  -                                               state := 3
  +                                               state := TryWithState.HaveHandlerEnumerator
                                                  x.MoveNext())
  -                                    | 3 ->   
  +                                    | TryWithState.HaveHandlerEnumerator ->   
                                           let! res = enum.Value.MoveNext() 
                                           return (match res with 
                                                   | Some _ -> res
  
positive.code:           let! moven = ie.MoveNext() 
            b := moven }
  
    /// Implements the 'TryWith' functionality for computation builder
    // this pushes the handler through all the async computations
    let tryWith (inp: AsyncSeq<'T>) (handler : exn -> AsyncSeq<'T>) : AsyncSeq<'T> = 
          { new IAsyncEnumerable<'T> with 
                member x.GetEnumerator() = 
                    let state = ref -1
                    let enum = ref Unchecked.defaultof<IAsyncEnumerator<'T>>
                    // state -1: not started
                    // state 0: have body enumerator
                    // state 1: finished
                    // state 2: exception happened, about to get handler enumerator
                    // state 3: have handler enumerator
                    { new IAsyncEnumerator<'T> with 
                          member x.MoveNext() = 
                              async { match !state with 
                                      | -1 -> 
                                          let res = ref Unchecked.defaultof<_>
                                          try 
                                              res := Choice1Of2 (inp.GetEnumerator())
  
negative.code: 
  
    let delay (f: unit -> AsyncSeq<'T>) : AsyncSeq<'T> = 
        { new IAsyncEnumerable<'T> with 
            member x.GetEnumerator() = f().GetEnumerator() }
  
  
    type BindState =
       | NotStarted     = -1
       | HaveEnumerator = 0
       | Finished        = 1
  
    let bindAsync (f: 'T -> AsyncSeq<'U>) (inp : Async<'T>) : AsyncSeq<'U> = 
          { new IAsyncEnumerable<'U> with 
                member x.GetEnumerator() = 
                    let state = ref BindState.NotStarted
                    let enum = ref Unchecked.defaultof<IAsyncEnumerator<'U>>
                    { new IAsyncEnumerator<'U> with 
                          member x.MoveNext() = 
                              async { match !state with 
                                      | BindState.NotStarted -> 
                                          let! v = inp 
                                          return! 
                                             (let s = f v
                                              let e = s.GetEnumerator()
                                              enum := e
                                              state := BindState.HaveEnumerator
                                              x.MoveNext())
                                      | BindState.HaveEnumerator ->   
                                          let! res = enum.Value.MoveNext() 
                                          return (match res with
                                                  | None -> 
  