anchor.diff:           ysK.Value <- ResizeArray<_> ()
            let xs = xs.GetEnumerator ()
            if xs.MoveNext () then
  -           (x2yJ xs.Current).DoJob (&wr, {new Cont<_> () with
  +           let yK' = {new Cont<'y> () with
               override yK'.GetProc (wr) = ysK.GetProc (&wr)
  -            override yK'.DoHandle (wr, e) = ysK.DoHandle (&wr, e)
  +            override yK'.DoHandle (wr, e) =
  +             wr.Handler <- ysK ; xs.Dispose () ; 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)
  +               wr.Handler <- ysK ; xs.Dispose () ; 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)})
  +               wr.Handler <- ysK ; xs.Dispose () ; ysK.DoWork (&wr)}
  +           wr.Handler <- yK'
  +           (x2yJ xs.Current).DoJob (&wr, yK')
            else
  +           xs.Dispose ()
              Work.Do (ysK, &wr)}
   
       let foldJob (xy2xJ: 'x -> 'y -> Job<'x>) (x: 'x) (ys: seq<'y>) =
  
positive.code:                 let i = Util.dec &nth
                  Worker.PushNew (&wr, {new Cont_State<_, _, _, _> (x, i, x2yJ) with
                   override yK'.GetProc (wr) = cc'.ysK.GetProc (&wr)
                   override yK'.DoHandle (wr, e) = ConCollect<'y>.OutsideDoHandle (cc', &wr, e)
                   override yK'.DoCont (wr, y) =
                    yK'.Value <- y
                    yK'.State2 <- ~~~ yK'.State2
  
negative.code:         | exns -> exns
       exns.Add e
       Monitor.Exit self
      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<'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 xJs = xJs.GetEnumerator ()
         let join = ConIgnore (xJs, uK)
         wr.Handler <- join
         while xJs.MoveNext () do
           let xJ = xJs.Current
           ConIgnore.Inc join
  