anchor.diff:                     cc'.Lock.Enter (&wr, xK')
                    else
                      cc'.ysK.Value.[i] <- xK'.Value
  -                   ConCollect<'x>.Done (cc', &wr)
  +                   ConCollect<Job<'x>, 'x>.Done (cc', &wr)
                  | xJ ->
                    xK'.State1 <- null
                    xJ.DoJob (&wr, xK')})
  -          ConCollect<'x>.Done (cc', &wr)}
  +          xs.Dispose ()
  +          cc'.xs <- null
  +          ConCollect<Job<'x>, 'x>.Done (cc', &wr)}
          wr.Handler <- cc'
          cc'.Lock.Enter (&wr, cc')}
   
  -  type ConIgnore =
  +  type ConIgnore<'x> =
       inherit Handler
       [<DefaultValue>] val mutable Finished: int
       [<DefaultValue>] val mutable Started: int
       [<DefaultValue>] val mutable Exns: ResizeArray<exn> 
  +    val mutable xs: IEnumerator<'x>
       val uK: Cont<unit>
  -    new (uK) = {uK = uK}
  -    static member inline Inc (self: ConIgnore) =
  +    new (xs, uK) = {xs=xs; uK=uK}
  +    static member inline Inc (self: ConIgnore<'x>) =
        self.Started <- self.Started - 1
  -    static member Continue (self: ConIgnore, wr: byref<Worker>) =
  +    static member Continue (self: ConIgnore<'x>, wr: byref<Worker>) =
        let uK = self.uK
        wr.Handler <- uK
  +     match self.xs with
  +      | null -> ()
  +      | xs -> xs.Dispose ()
        match self.Exns with
         | null -> uK.DoWork (&wr)
         | exns -> uK.DoHandle (&wr, aggrExn exns)
  -    static member inline Dec (self: ConIgnore, wr: byref<Worker>) =
  +    static member inline Dec (self: ConIgnore<'x>, wr: byref<Worker>) =
        if Interlocked.Increment &self.Finished = self.Started then
          ConIgnore.Continue (self, &wr)
  -    static member inline Done (self: ConIgnore, wr: byref<Worker>) =
  +    static member inline Done (self: ConIgnore<'x>, wr: byref<Worker>) =
        self.Started <- 1 - self.Started
  -     ConIgnore.Dec (self, &wr)
  -    static member AddExn (self: ConIgnore, e: exn) =
  +     ConIgnore<'x>.Dec (self, &wr)
  +    static member AddExn (self: ConIgnore<'x>, e: exn) =
        Monitor.Enter self
        let exns =
          match self.Exns with
  
positive.code:          ysK.Value <- ResizeArray<_> ()
           let xs = xs.GetEnumerator ()
           if xs.MoveNext () then
             (x2yJ xs.Current).DoJob (&wr, {new Cont<_> () with
              override yK'.GetProc (wr) = ysK.GetProc (&wr)
              override yK'.DoHandle (wr, e) = ysK.DoHandle (&wr, e)
              override yK'.DoWork (wr) =
               ysK.Value.Add yK'.Value
               if xs.MoveNext () then
                 (x2yJ xs.Current).DoJob (&wr, yK')
               else
                 ysK.DoWork (&wr)
              override yK'.DoCont (wr, y) =
               ysK.Value.Add y
               if xs.MoveNext () then
                 (x2yJ xs.Current).DoJob (&wr, yK')
               else
                 ysK.DoWork (&wr)})
           else
             Work.Do (ysK, &wr)}
  
      let foldJob (xy2xJ: 'x -> 'y -> Job<'x>) (x: 'x) (ys: seq<'y>) =
  
negative.code:                   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 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')
  