anchor.diff:    ///////////////////////////////////////////////////////////////////////
   
     let delay (u2xJ: unit -> Job<'x>) =
  -    {new Job<'x>() with
  +    {new Job<'x> () with
         override xJ'.DoJob (wr, xK) =
          (u2xJ ()).DoJob (&wr, xK)}
   
     let delayWith (x2yJ: 'x -> Job<'y>) (x: 'x) =
  -    {new Job<'y>() with
  +    {new Job<'y> () with
         override yJ'.DoJob (wr, yK) =
          (x2yJ x).DoJob (&wr, yK)}
   
     let lift (x2y: 'x -> 'y) (x: 'x) =
  -    {new Job<'y>() with
  +    {new Job<'y> () with
         override yJ'.DoJob (wr, yK) = Cont.Do (yK, &wr, x2y x)}
   
     let thunk (u2x: unit -> 'x) =
  -    {new Job<'x>() with
  +    {new Job<'x> () with
         override xJ'.DoJob (wr, xK) = Cont.Do (xK, &wr, u2x ())}
   
     let forN (n: int) (xJ: Job<'x>) =
  -    {new Job<unit>() with
  +    {new Job<unit> () with
         override uJ'.DoJob (wr, uK) =
  -       {new Cont_State<_, _>(n) with
  +       {new Cont_State<_, _> (n) with
            override xK'.DoHandle (wr, e) = uK.DoHandle (&wr, e)
            override xK'.DoCont (wr, _) =
             let n = xK'.State
  
positive.code: 
      module Con =
        let iterJob (x2yJ: 'x -> Job<'y>) (xs: seq<'x>) =
          {new Job<unit>() with
            override uJ'.DoJob (wr, uK) =
             let join = ConIgnore_State (uK, x2yJ)
             wr.Handler <- join
  
negative.code:         override xyJ'.DoJob (wr, xyK) =
            if 0 <= Scheduler.Waiters then
              let yK' = ParTuple<'x, 'y> (xyK)
              Worker.PushNew (&wr, {new Cont_State<_, _> (xJ) with
               override xK'.DoHandle (wr, e) = yK'.DoHandle (&wr, e)
               override xK'.DoCont (wr, a) = yK'.DoOtherCont (&wr, a)
               override xK'.DoWork (wr) =
  