anchor.diff:      method &Await(aCompletion: __ElementsIAwaitCompletion): Boolean; // true = yield; false = long done
   
       {$HIDE W38}
  -    method Wait; reintroduce;virtual;
  +    method Wait; reintroduce; virtual;
       {$SHOW W38}
       method Wait(aTimeoutMSec: Integer): Boolean; virtual;
   
       method Start(aScheduler: dispatch_queue_t := nil); virtual;
  -
  -    
  -    class property ThreadSyncHelper: IThreadSyncHelper := new DefaultThreadSyncHelper;
  -  end;
  +  
  +    class property ThreadSyncHelper: IThreadSyncHelper := new __ElementsDefaultThreadSyncHelper;
  +  end;
  +  
     __ElementsTask1<T> = public class(__ElementsTask)
     assembly
       fResult: T;
  +    constructor(aDelegate: Object; aState: Object); empty;
       method getResult: T;
  -    constructor(aDelegate: Object; aState: Object); empty;
  +    method DoRun; override;
     public
       constructor(aIn: TaskBlockGen<T>; aState: Object := nil);
       method ContinueWith(aAction: block(aTask: __ElementsTask1<T>); aState: Object := nil): __ElementsTask;
       method ContinueWith<TR>(aAction: block(aTask: __ElementsTask1<T>): TR; aState: Object := nil): __ElementsTask1<TR>;
  -    method run; override;
       property &Result: T read getResult;
     end;
  -
     
     __ElementsTaskCompletionSource<T> = public class
     private 
       fTask: __ElementsTask1<T>;
     public
       constructor(aState: Object := nil);
  -
       method SetException(ex: NSException);
       method SetResult(val: T);
  -
       property Task: __ElementsTask1<T> read fTask;
     end;
  -
  -  TaskCompletionSource<T> = public __ElementsTaskCompletionSource<T>;
  -  Task = public __ElementsTask;
  -  Task1<T> = public __ElementsTask1<T>;
   
     TaskCompletionSourceTask<T> = class(__ElementsTask1<T>)
     assembly
  -  public
  -    method run; override; empty;
  +    method DoRun; override; empty;
     end;
   
     __ElementsIAwaitCompletion = public interface
       method moveNext(aState: Object);
     end;
   
  - IThreadSyncHelper = public interface
  +  IThreadSyncHelper = public interface
       method GetThreadContext: dispatch_queue_t;
       method SyncBack(aContext: dispatch_queue_t; aAction: dispatch_block_t);
     end;
   
  -  DefaultThreadSyncHelper = public class(IThreadSyncHelper)
  -  private
  +  __ElementsDefaultThreadSyncHelper = public class(IThreadSyncHelper)
     public
       method SyncBack(aContext: dispatch_queue_t; aAction: dispatch_block_t);
       method GetThreadContext: dispatch_queue_t;
  
positive.code:   constructor(Object(aIn), aState);
  end;
  
  method __ElementsTask.run;
  begin
    fLock.lock;
    try
  
negative.code:   TaskState = enum(Created, Queued, Started, Done) of Integer;
    TaskBlock = public block();
    TaskBlockGen<T> = public block(): T;
  
    TaskCompletionSource<T> = public __ElementsTaskCompletionSource<T>;
    Task = public __ElementsTask;
    Task1<T> = public __ElementsTask1<T>;
    
    __ElementsTask = public class
    assembly
      fState: TaskState;
  