anchor.diff:                    yK'.State1 <- Unchecked.defaultof<_>
                     yK'.State2 <- Unchecked.defaultof<_>
                     (x2yJ x).DoJob (&wr, yK')})
  +           xs.Dispose ()
  +           join.xs <- null
              ConIgnore.Done (join, &wr)}
   
         let mapJob (x2yJ: 'x -> Job<'y>) (xs: seq<'x>) =
           {new Job<ResizeArray<'y>> () with
             override ysJ'.DoJob (wr, ysK_) =
              ysK_.Value <- ResizeArray<_> ()
  -           let xs = xs.GetEnumerator ()
  -           let cc' = {new ConCollect<'y> (ysK_) with
  +           let cc' = {new ConCollect<'x, 'y> (xs.GetEnumerator (), ysK_) with
                override cc'.DoWork (wr) =
                 let mutable nth = 0
  +              let xs = cc'.xs
                 while xs.MoveNext () do
                   let x = xs.Current
                   cc'.Lock.ExitAndEnter (&wr, cc')
  
positive.code:                        cc'.Lock.Enter (&wr, yK')
                       else
                         cc'.ysK.Value.[i] <- yK'.Value
                         ConCollect<'y>.Done (cc', &wr)
                     | _ ->
                       let x = yK'.State1
                       yK'.State3 <- Unchecked.defaultof<_>
                       yK'.State1 <- Unchecked.defaultof<_>
                       (x2yJ x).DoJob (&wr, yK')})
                ConCollect<'y>.Done (cc', &wr)}
             wr.Handler <- cc'
             cc'.Lock.Enter (&wr, cc')}
  
  
negative.code:           exns
          | exns -> exns
       exns.Add e
       ConCollect<'x, 'y>.Done (cc', &wr)
      static member OutsideDoHandle (cc': ConCollect<'x, 'y>, wr: byref<Worker>, e) =
       cc'.Lock.Enter (&wr, {new Work () with
        override wk.GetProc (_) = raise <| NotImplementedException ()
        override wk.DoHandle (_, _) = raise <| NotImplementedException ()
        override wk.DoWork (wr) = cc'.DoHandle (&wr, e)})
      new (xs, ysK) = {inherit Work (); xs=xs; ysK=ysK}
  
    let conCollect (xJs: seq<Job<'x>>) =
      {new Job<ResizeArray<'x>> () with
        override xsJ'.DoJob (wr, xsK_) =
         xsK_.Value <- ResizeArray<_> ()
         let cc' = {new ConCollect<Job<'x>, 'x> (xJs.GetEnumerator (), xsK_) with
           override cc'.DoWork (wr) =
            let mutable nth = 0
            let xs = cc'.xs
            while xs.MoveNext () do
              let xJ = xs.Current
              cc'.Lock.ExitAndEnter (&wr, cc')
              cc'.ysK.Value.Add Unchecked.defaultof<_>
              let i = Util.dec &nth
              Worker.PushNew (&wr, {new Cont_State<_, _, _> (xJ, i) with
               override xK'.GetProc (wr) = cc'.ysK.GetProc (&wr)
               override xK'.DoHandle (wr, e) =
                ConCollect<Job<'x>, 'x>.OutsideDoHandle (cc', &wr, e)
               override xK'.DoCont (wr, x) =
                xK'.Value <- x
                xK'.State2 <- ~~~ xK'.State2
  