anchor.diff:        let iterJob (x2yJ: 'x -> Job<'y>) (xs: seq<'x>) =
           {new Job<unit> () with
             override uJ'.DoJob (wr, uK) =
  -           let join = ConIgnore_State (uK, x2yJ)
  +           let join = ConIgnore (uK)
              wr.Handler <- join
              let xs = xs.GetEnumerator ()
              while xs.MoveNext () do
                let x = xs.Current
                ConIgnore.Inc join
  -             Worker.PushNew (&wr, {new Cont_State<_, _> () with
  +             Worker.PushNew (&wr, {new Cont_State<_, _, _> (x, x2yJ) with
                 override yK'.DoHandle (wr, e) = ConIgnore.OutsideDoHandle (join, &wr, e)
                 override yK'.DoCont (wr, _) = ConIgnore.Dec (join, &wr)
                 override yK'.DoWork (wr) =
  -               if yK'.State then
  -                 ConIgnore.Dec (join, &wr)
  -               else
  -                 yK'.State <- true
  -                 (join.State x).DoJob (&wr, yK')})
  +               let x2yJ = yK'.State2
  +               match x2yJ :> obj with
  +                | null ->
  +                  ConIgnore.Dec (join, &wr)
  +                | _ ->
  +                  let x = yK'.State1
  +                  yK'.State1 <- Unchecked.defaultof<_>
  +                  yK'.State2 <- Unchecked.defaultof<_>
  +                  (x2yJ x).DoJob (&wr, yK')})
              ConIgnore.Done (join, &wr)}
   
         let mapJob (x2yJ: 'x -> Job<'y>) (xs: seq<'x>) =
  
positive.code:              override cc'.DoWork (wr) =
                let mutable nth = 0
                while xs.MoveNext () do
                  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)
                   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)}
             wr.Handler <- cc'
             cc'.Lock.Enter (&wr, cc')}
  
  
negative.code:                    cc'.Lock.Enter (&wr, xK')
                   else
                     cc'.ysK.Value.[i] <- xK'.Value
                     ConCollect<'x>.Done (cc', &wr)
                 | xJ ->
                   xK'.State1 <- null
                   xJ.DoJob (&wr, xK')})
            ConCollect<'x>.Done (cc', &wr)}
         wr.Handler <- cc'
         cc'.Lock.Enter (&wr, cc')}
  
  