anchor.diff:          | exns -> exns
        exns.Add e
        Monitor.Exit self
  -    static member OutsideDoHandle (self: ConIgnore, wr: byref<Worker>, e: exn) =
  -     ConIgnore.AddExn (self, e)
  -     ConIgnore.Dec (self, &wr)
  +    static member OutsideDoHandle (self: ConIgnore<'x>, wr: byref<Worker>, e: exn) =
  +     ConIgnore<'x>.AddExn (self, e)
  +     ConIgnore<'x>.Dec (self, &wr)
       override self.GetProc (wr) = self.uK.GetProc (&wr)
       override self.DoHandle (wr: byref<Worker>, e: exn) =
  -     ConIgnore.AddExn (self, e)
  -     ConIgnore.Done (self, &wr)
  +     ConIgnore<'x>.AddExn (self, e)
  +     ConIgnore<'x>.Done (self, &wr)
   
     let conIgnore (xJs: seq<Job<'x>>) =
       {new Job<unit> () with
         override uJ.DoJob (wr, uK) =
  -       let join = ConIgnore (uK)
  +       let xJs = xJs.GetEnumerator ()
  +       let join = ConIgnore (xJs, uK)
          wr.Handler <- join
  -       let xJs = xJs.GetEnumerator ()
          while xJs.MoveNext () do
            let xJ = xJs.Current
            ConIgnore.Inc join
  
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:        let xJs = xJs.GetEnumerator ()
         xsK.Value <- ResizeArray<_> ()
         if xJs.MoveNext () then
           let xK' = {new Cont<'x> () with
            override xK'.GetProc (wr) = xsK.GetProc (&wr)
            override xK'.DoHandle (wr, e) =
             wr.Handler <- xsK ; xJs.Dispose () ; xsK.DoHandle (&wr, e)
            override xK'.DoWork (wr) =
             xsK.Value.Add xK'.Value
             if xJs.MoveNext () then
               xJs.Current.DoJob (&wr, xK')
             else
               wr.Handler <- xsK ; xJs.Dispose () ; xsK.DoWork (&wr)
            override xK'.DoCont (wr, x) =
             xsK.Value.Add x
             if xJs.MoveNext () then
               xJs.Current.DoJob (&wr, xK')
             else
               wr.Handler <- xsK ; xJs.Dispose () ; xsK.DoWork (&wr)}
           wr.Handler <- xK'
           xJs.Current.DoJob (&wr, xK')
         else
           xJs.Dispose () ; Work.Do (xsK, &wr)}
  
    let seqIgnore (xJs: seq<Job<'x>>) =
      {new Job<unit> () with
        override self.DoJob (wr, uK) =
         let xJs = xJs.GetEnumerator ()
         if xJs.MoveNext () then
           let xK' = {new Cont<'x> () with
            override xK'.GetProc (wr) = uK.GetProc (&wr)
            override xK'.DoHandle (wr, e) =
             wr.Handler <- uK ; xJs.Dispose () ; uK.DoHandle (&wr, e)
            override xK'.DoWork (wr) =
             if xJs.MoveNext () then
               xJs.Current.DoJob (&wr, xK')
             else
               wr.Handler <- uK ; xJs.Dispose () ; uK.DoWork (&wr)
            override xK'.DoCont (wr, _) =
             if xJs.MoveNext () then
               xJs.Current.DoJob (&wr, xK')
             else
               wr.Handler <- uK ; xJs.Dispose () ;  uK.DoWork (&wr)}
           wr.Handler <- xK'
           xJs.Current.DoJob (&wr, xK')
         else
           xJs.Dispose () ; Work.Do (uK, &wr)}
  
    type [<AbstractClass>] ConCollect<'x, 'y> =
      inherit Work
      [<DefaultValue>] val mutable Lock: WorkQueueLock
      [<DefaultValue>] val mutable N: int
      [<DefaultValue>] val mutable Exns: ResizeArray<exn>
      val mutable xs: IEnumerator<'x>
      val ysK: Cont<ResizeArray<'y>>
      static member Continue (cc': ConCollect<'x, 'y>, wr: byref<Worker>) =
         let ysK = cc'.ysK
         wr.Handler <- ysK
         match cc'.xs with
          | null -> ()
          | xs -> xs.Dispose ()
         match cc'.Exns with
          | null -> ysK.DoWork (&wr)
          | exns -> ysK.DoHandle (&wr, aggrExn exns)
      static member inline Done (cc': ConCollect<'x, 'y>, wr: byref<Worker>) =
       if cc'.ysK.Value.Count < Util.inc &cc'.N then
         ConCollect<'x, 'y>.Continue (cc', &wr)
      override cc'.GetProc (wr) = cc'.ysK.GetProc (&wr)
      override cc'.DoHandle (wr, e) =
       let exns =
  