anchor.diff:               override cc'.DoWork (wr) =
                 let mutable nth = 0
                 while xs.MoveNext () do
  +                let x = xs.Current
                   cc'.Lock.ExitAndEnter (&wr, cc')
                   cc'.ysK.Value.Add Unchecked.defaultof<_>
  -                Worker.PushNew (&wr, {new Cont_State<_, _, _, _> (xs.Current, Util.dec &nth, x2yJ) with
  -                 override yK'.DoHandle (wr, e) = cc'.OutsideDoHandle (&wr, e)
  +                Worker.PushNew (&wr, {new Cont_State<_, _, _, _> (x, Util.dec &nth, x2yJ) with
  +                 override yK'.DoHandle (wr, e) = ConCollect<'y>.OutsideDoHandle (cc', &wr, e)
                    override yK'.DoCont (wr, y) =
                     yK'.Value <- y
                     yK'.State2 <- ~~~ yK'.State2
                     cc'.Lock.Enter (&wr, yK')
                    override yK'.DoWork (wr) =
                     let x2yJ = yK'.State3
  -                  if LanguagePrimitives.PhysicalEquality x2yJ Unchecked.defaultof<_> then
  -                    let i = yK'.State2
  -                    if i < 0 then
  -                      yK'.State2 <- ~~~ i
  -                      cc'.Lock.Enter (&wr, yK')
  -                    else
  -                      cc'.ysK.Value.[i] <- yK'.Value
  -                      cc'.Inc (&wr)
  -                  else
  -                    let x = yK'.State1
  -                    yK'.State3 <- Unchecked.defaultof<_>
  -                    yK'.State1 <- Unchecked.defaultof<_>
  -                    (x2yJ x).DoJob (&wr, yK')})
  -              cc'.Inc (&wr)}
  +                  match x2yJ :> obj with
  +                   | null ->
  +                     let i = yK'.State2
  +                     if i < 0 then
  +                       yK'.State2 <- ~~~ i
  +                       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')}
   
  
positive.code:     [<DefaultValue>] val mutable N: int
      [<DefaultValue>] val mutable Exns: ResizeArray<exn>
      val ysK: Cont<ResizeArray<'y>>
      member cc'.Inc (wr: byref<Worker>) =
       if cc'.ysK.Value.Count < Util.inc &cc'.N then
         let ysK = cc'.ysK
         wr.Handler <- ysK
         match cc'.Exns with
          | null -> ysK.DoWork (&wr)
          | exns -> Handler.DoHandle (ysK, &wr, AggregateException exns)
      override cc'.DoHandle (wr, e) =
       let exns =
         match cc'.Exns with
  
negative.code:        wr.Handler <- join
         let xJs = xJs.GetEnumerator ()
         while xJs.MoveNext () do
           let xJ = xJs.Current
           ConIgnore.Inc join
           Worker.PushNew (&wr, {new Cont_State<_, _> (xJ) with
            override xK'.DoHandle (wr, e) = ConIgnore.OutsideDoHandle (join, &wr, e)
            override xK'.DoCont (wr, _) = ConIgnore.Dec (join, &wr)
            override xK'.DoWork (wr) =
  