diff --git a/.gitignore b/.gitignore
index e9d123f..a63df36 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,14 +30,14 @@
 # Default Delphi compiler directories
 # Content of this directories are generated with each Compile/Construct of a project.
 # Most of the time, files here have not there place in a code repository.
-#Win32/
-#Win64/
-#OSX64/
-#OSXARM64/
-#Android/
-#Android64/
-#iOSDevice64/
-#Linux64/
+Win32/
+Win64/
+OSX64/
+OSXARM64/
+Android/
+Android64/
+iOSDevice64/
+Linux64/
 
 # Delphi compiler-generated binaries (safe to delete)
 *.exe
diff --git a/Src/Myc.Atomic.pas b/Src/Myc.Atomic.pas
new file mode 100644
index 0000000..26a6d6a
--- /dev/null
+++ b/Src/Myc.Atomic.pas
@@ -0,0 +1,108 @@
+unit Myc.Atomic;
+
+interface
+
+uses
+    Myc.Heap;
+
+type
+    IAtomicStack<T> = interface
+        function Pop: T;
+        function TryPop( out Item: T ): Boolean;
+        procedure Push( const Data: T );
+    end;
+
+    TMycAtomicStack<T> = class( TInterfacedObject, IAtomicStack<T> )
+    private
+    type
+        PItem = ^TItem;
+        TItem = packed record
+            Next: Pointer;
+            Data: T;
+        end;
+
+    var
+        FSList: PSList;
+
+    public
+        constructor Create;
+        destructor Destroy; override;
+        function Pop: T; inline;
+        function TryPop(out Item: T): Boolean; inline;
+        procedure Push( const Data: T ); inline;
+        function Alloc: PItem; inline;
+        procedure PushPtr(Item: PItem); inline;
+        function PopPtr: PItem;
+    end;
+
+implementation
+
+uses Winapi.Windows;
+
+constructor TMycAtomicStack<T>.Create;
+begin
+    inherited Create;
+    FSList := TSList.Create;
+end;
+
+destructor TMycAtomicStack<T>.Destroy;
+var
+    Item: PItem;
+begin
+    Item := PopPtr;
+    while Item <> nil do
+    begin
+        Item.Data := Default ( T );
+        FreeMem( Item );
+        Item := PopPtr;
+    end;
+
+    FSList.Free;
+    inherited;
+end;
+
+function TMycAtomicStack<T>.Alloc: PItem;
+begin
+    Result := AllocMem( sizeof( TItem ) );
+end;
+
+function TMycAtomicStack<T>.Pop: T;
+begin
+    if not TryPop( Result ) then
+        Result := Default ( T );
+end;
+
+function TMycAtomicStack<T>.PopPtr: PItem;
+begin
+    Result := PItem( FSList.Pop );
+end;
+
+procedure TMycAtomicStack<T>.Push(const Data: T);
+var
+    Item: PItem;
+begin
+    Item := Alloc;
+    Item.Data := Data;
+    PushPtr( Item );
+end;
+
+procedure TMycAtomicStack<T>.PushPtr(Item: PItem);
+begin
+    FSList.Push( PSListEntry(Item) );
+end;
+
+function TMycAtomicStack<T>.TryPop(out Item: T): Boolean;
+var
+    P: PItem;
+begin
+    P := PopPtr;
+    Result := P <> nil;
+    if Result then
+    begin
+        Item := P.Data;
+        P.Data := Default ( T );
+        FreeMem( P );
+    end;
+end;
+
+end.
diff --git a/Src/Myc.Heap.pas b/Src/Myc.Heap.pas
new file mode 100644
index 0000000..9d2e547
--- /dev/null
+++ b/Src/Myc.Heap.pas
@@ -0,0 +1,144 @@
+unit Myc.Heap;
+
+interface
+
+{$align on}
+uses
+    {$ifndef NO_FASTMM}
+    FastMM5,
+    {$endif}
+    Winapi.Windows;
+
+type
+    TSListEntry = Winapi.Windows.TSListEntry;
+    PSListEntry = Winapi.Windows.PSListEntry;
+
+    PSList = ^TSList;
+    TSList = packed record
+    private
+        FList: TSListHeader;
+
+    public
+        class function Create: PSList; static;
+        procedure Init;
+        procedure Free;
+        function Push( ListEntry: PSListEntry ): PSListEntry;
+        function Pop: PSListEntry;
+        function QueryDepth: Integer;
+    end;
+
+procedure GetMemAligned( var P; Size: NativeUInt );
+procedure FreeMemAligned( var P );
+
+procedure InitializeSListHead( ListHead: PSListHeader ); stdcall; external kernel32;
+function InterlockedPushEntrySList( ListHead: PSListHeader; ListEntry: PSListEntry ): PSListEntry; stdcall; external kernel32;
+function InterlockedPopEntrySList( ListHead: PSListHeader ): PSListEntry; stdcall; external kernel32;
+function QueryDepthSList( ListHead: PSListHeader ): Word; stdcall; external kernel32;
+
+implementation
+
+const
+    // Defines the alignment boundary (16 bytes for SList and common SIMD operations)
+    AlignmentBoundary = 16;
+    // Mask to achieve alignment, (AlignmentBoundary - 1)
+    AlignmentMask = AlignmentBoundary - 1;
+
+{$ifdef NO_FASTMM}
+
+const
+    MetaDataSize = SizeOf(Pointer);
+
+procedure GetMemAligned(var P; Size: NativeUInt);
+var
+    rawAllocatedPtr: Pointer;
+    alignedUserPtrVal: NativeUInt;
+    rawAllocatedPtrVal: NativeUInt;
+    totalSizeToAllocate: NativeUInt;
+begin
+    totalSizeToAllocate := Size + MetaDataSize + AlignmentMask;
+    System.GetMem(rawAllocatedPtr, totalSizeToAllocate);
+    if rawAllocatedPtr = nil then
+    begin
+        Pointer(P) := nil;
+        Exit;
+    end;
+    rawAllocatedPtrVal := NativeUInt(rawAllocatedPtr);
+    alignedUserPtrVal := (rawAllocatedPtrVal + MetaDataSize + AlignmentMask) and not AlignmentMask;
+    Pointer(P) := Pointer(alignedUserPtrVal);
+    PPointer(alignedUserPtrVal - MetaDataSize)^ := rawAllocatedPtr;
+    Assert((NativeUInt(P) and AlignmentMask) = 0, 'GetMemAligned did not return an aligned pointer.');
+end;
+
+procedure FreeMemAligned( var P );
+var
+    alignedUserPtrVal: NativeUInt;
+    rawAllocatedPtr: Pointer;
+    ptrToRawAllocatedPtr: PPointer;
+begin
+    if Pointer(P) = nil then
+        Exit;
+    alignedUserPtrVal := NativeUInt(P);
+    ptrToRawAllocatedPtr := PPointer(alignedUserPtrVal - MetaDataSize);
+    rawAllocatedPtr := ptrToRawAllocatedPtr^;
+    System.FreeMem(rawAllocatedPtr);
+    Pointer(P) := nil;
+end;
+
+{$else}
+
+procedure GetMemAligned(var P; Size: NativeUInt); inline;
+begin
+    FastMM_EnterMinimumAddressAlignment(maa16Bytes);
+    try
+        GetMem( Pointer(P), Size );
+    finally
+        FastMM_ExitMinimumAddressAlignment(maa16Bytes)
+    end;
+end;
+
+procedure FreeMemAligned( var P ); inline;
+begin
+    FreeMem( Pointer(P) );
+end;
+
+{$endif}
+
+{ TSList }
+
+class function TSList.Create: PSList;
+begin
+    GetMemAligned( Result, sizeof( TSList ) );
+    Result.Init;
+end;
+
+procedure TSList.Free;
+var
+    P: Pointer;
+begin
+    P := @Self;
+    FreeMemAligned( P );
+end;
+
+procedure TSList.Init;
+begin
+    Assert( NativeUInt( @FList ) and AlignmentMask = 0, 'ListHeader not aligned' );
+    InitializeSListHead( @FList );
+end;
+
+function TSList.Pop: PSListEntry;
+begin
+    Result := InterlockedPopEntrySList( @FList );
+end;
+
+function TSList.Push( ListEntry: PSListEntry ): PSListEntry;
+begin
+    Assert( NativeUInt( ListEntry ) and AlignmentMask = 0, 'ListEntry not aligned' );
+    Result := InterlockedPushEntrySList( @FList, ListEntry );
+end;
+
+function TSList.QueryDepth: Integer;
+begin
+    Result := QueryDepthSList( @FList );
+end;
+
+end.
diff --git a/Src/Myc.Signals.pas b/Src/Myc.Signals.pas
new file mode 100644
index 0000000..f8c7a89
--- /dev/null
+++ b/Src/Myc.Signals.pas
@@ -0,0 +1,1009 @@
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+///
+///  Mycelium Framework
+///  ------------------
+///
+///  (c)2007-2019 Michael Schimmel
+///               Ehrenhainstraße 40
+///               42329 Wuppertal / Germany
+///               info@mycelium.net
+///
+///  All rights reserved.
+///
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+unit Myc.Signals;
+
+interface
+
+uses
+    System.SysUtils, System.SyncObjs,
+    Myc.Atomic;
+
+{.$define DEBUG_SIGNALS}
+
+type
+    IMyc2Sink = interface
+        function Notify: Boolean;
+    end;
+
+    IMyc2Flag = interface( IMyc2Sink )
+        function Reset: Boolean;
+    end;
+
+    {$message hint 'Replace TSignalTag by IMycDeletable? '}
+    TSignalTag = NativeInt;
+
+    IMyc2Signal = interface
+        function Advise( const Sink: IMyc2Sink ): TSignalTag;
+        procedure Unadvise( Tag: TSignalTag );
+    end;
+
+    IMyc2Notifier = interface( IMyc2Sink )
+        {$region 'property access'}
+        function GetSignal: IMyc2Signal;
+        {$endregion}
+        property Signal: IMyc2Signal read GetSignal;
+    end;
+
+    IMyc2State = interface( IMyc2Signal )
+        {$region 'property access'}
+        function GetIsSet: Boolean;
+        {$endregion}
+        property IsSet: Boolean read GetIsSet;
+    end;
+
+    IMyc2Condition = interface( IMyc2Sink )
+        {$region 'property access'}
+        function GetState: IMyc2State;
+        {$endregion}
+        property State: IMyc2State read GetState;
+    end;
+
+    IMyc2Event = interface( IMyc2Condition )
+        function Reset: Boolean;
+    end;
+
+    TMycSinkList = record
+    type
+        PItem = ^TItem;
+
+        TItem = record
+            Next, Prev: PItem;
+            Sink: IMyc2Sink;
+        end;
+
+    strict private
+        FFirst: NativeUInt;
+        FList: PItem;
+
+        {$ifdef DEBUG_SIGNALS}
+        FCount: Integer;
+        {$endif}
+        class var
+            [volatile] FItems: TMycAtomicStack<TItem>;
+        [volatile]
+        FPendingCnt: Int64;
+        [volatile]
+        FUsedCnt: Int64;
+
+        class constructor CreateClass;
+        class destructor DestroyClass;
+        class function AllocItem: PItem; static; inline;
+        class procedure FreeItem( Item: PItem ); static; inline;
+
+    public
+        procedure Create;
+        procedure Destroy;
+        function Advise( const Sink: IMyc2Sink ): TSignalTag;
+        procedure Unadvise( Tag: TSignalTag );
+        procedure UnadviseAll;
+        procedure Finalize;
+        procedure Lock; inline;
+        procedure Release; inline;
+        function IsLocked: Boolean; inline;
+        function IsFinalized: Boolean; inline;
+        procedure Notify;
+    end;
+
+    TMyc2Signal = class( TInterfacedObject, IMyc2Signal, IMyc2State, IMyc2Sink )
+    private
+        FList: TMycSinkList;
+
+        class var
+            FNull: IMyc2Condition;
+
+    protected
+        class constructor CreateClass;
+        class destructor DestroyClass;
+        function GetIsSet: Boolean; virtual;
+        function DoNotify: Boolean; virtual;
+    public
+        constructor Create;
+        destructor Destroy; override;
+
+        function Advise( const Sink: IMyc2Sink ): TSignalTag;
+        procedure Unadvise( Tag: TSignalTag );
+        function Notify: Boolean;
+
+        class function CreateAdvised( Count: Integer; const Getter: TFunc<Integer, IMyc2Signal> ): IMyc2Signal; overload;
+        class function IsStatic( const Signal: IMyc2Signal ): Boolean; overload; inline;
+        class function IsStatic( const Sink: IMyc2Sink ): Boolean; overload; inline;
+
+        class function MakeValid( const Signal: IMyc2Signal ): IMyc2Signal; overload; static; inline;
+        class function MakeValid( const Signals: array of IMyc2Signal ): TArray<IMyc2Signal>; overload; static;
+
+        class function CreateCounter( Count: Integer ): IMyc2Condition; static; inline;
+        class function CreateEvent( Init: Boolean ): IMyc2Event; static; inline;
+        class function CreateGroup( Count: Integer; const Getter: TFunc<Integer, IMyc2Signal> ): IMyc2Signal; overload;
+        class function CreateNotifier: IMyc2Notifier; static; inline;
+
+        class function CreateUnion( const Sigs: array of IMyc2Signal ): IMyc2Signal; static;
+        class function CreateConcat( const States: array of IMyc2State ): IMyc2State; static;
+
+        property IsSet: Boolean read GetIsSet;
+        class property Null: IMyc2Condition read FNull;
+    end;
+
+    TMyc2Notifier = class( TMyc2Signal, IMyc2Notifier )
+    protected
+        function GetSignal: IMyc2Signal;
+    end;
+
+    TMyc2Condition = class( TMyc2Signal, IMyc2Condition )
+    protected
+        function GetState: IMyc2State;
+    end;
+
+    TMyc2Event = class( TMyc2Condition, IMyc2Event )
+    private
+        [volatile]
+        FValue: Integer;
+
+    protected
+        function DoNotify: Boolean; override;
+        function GetIsSet: Boolean; override;
+
+    public
+        constructor Create( AInit: Boolean );
+        function Reset: Boolean; virtual;
+        property IsSet: Boolean read GetIsSet;
+    end;
+
+    TMyc2CountSignal = class sealed( TMyc2Condition )
+    private
+        [volatile]
+        FCount: Integer;
+
+    protected
+        function GetIsSet: Boolean; override;
+        function DoNotify: Boolean; override;
+
+    public
+        constructor Create( ACount: Integer );
+    end;
+
+    TMyc2SinkProc = class sealed( TInterfacedObject, IMyc2Sink )
+    private
+        FOnce: Boolean;
+        FProc: TProc;
+
+        function Notify: Boolean;
+
+    public
+        constructor Create( AOnce: Boolean; const AProc: TProc );
+        class function CreateSink( Once: Boolean; const Proc: TProc ): IMyc2Sink; static;
+    end;
+
+    TMyc2NullState = class sealed( TInterfacedObject, IMyc2Signal, IMyc2State )
+    protected
+        function Advise( const Sink: IMyc2Sink ): TSignalTag;
+        function GetIsSet: Boolean;
+        procedure Unadvise( Tag: TSignalTag );
+        procedure UnadviseAll;
+    end;
+
+    TMyc2NullSink = class sealed( TInterfacedObject, IMyc2Sink, IMyc2Condition )
+    private
+        FState: IMyc2State;
+        function GetState: IMyc2State;
+
+    protected
+        function Notify: Boolean;
+
+    public
+        constructor Create;
+        destructor Destroy; override;
+    end;
+
+    TMyc2Flag = class( TInterfacedObject, IMyc2Sink, IMyc2Flag )
+    private
+        FFlag: Integer;
+        function Notify: Boolean;
+        function Reset: Boolean;
+
+    public
+        constructor Create( AFlag: Boolean );
+    end;
+
+    TMycObserver<T: IMyc2Sink> = class
+    type
+        TNull = class( TInterfacedObject, IMycObserver<T> )
+        private
+            FSink: T;
+            function GetItem: T;
+
+        public
+            constructor Create( const ASink: T );
+        end;
+
+        TOne = class( TNull )
+        private
+            FSignal: IMyc2Signal;
+            FTag: TSignalTag;
+
+        public
+            constructor Create( const ASignal: IMyc2Signal; const ASink: T );
+            destructor Destroy; override;
+        end;
+
+        TArr = class( TNull )
+        private
+            FSignals: TArray<IMyc2Signal>;
+            FTags: TArray<TSignalTag>;
+
+        public
+            constructor Create( const ASignals: TArray<IMyc2Signal>; const ASink: T );
+            destructor Destroy; override;
+        end;
+
+    public
+        class function CreateObserver( const Signals: array of IMyc2Signal; const Item: T ): IMycObserver<T>; static;
+    end;
+
+    TMycSignalUnion = class( TInterfacedObject, IMyc2Signal )
+    private
+        FNotifier: IMyc2Notifier;
+        FSignals: TArray<IMyc2Signal>;
+        FTags: TArray<TSignalTag>;
+
+        function Advise( const Sink: IMyc2Sink ): TSignalTag;
+        procedure Unadvise( Tag: TSignalTag );
+
+    public
+        constructor Create( const ASignals: array of IMyc2Signal );
+        destructor Destroy; override;
+    end;
+
+implementation
+
+{ TMyc2Signal }
+
+constructor TMyc2Signal.Create;
+begin
+    inherited Create;
+    FList.Create;
+end;
+
+destructor TMyc2Signal.Destroy;
+begin
+    FList.Destroy;
+    inherited Destroy;
+end;
+
+class function TMyc2Signal.CreateAdvised( Count: Integer; const Getter: TFunc<Integer, IMyc2Signal> ): IMyc2Signal;
+var
+    i, j: Integer;
+    Sig: IMyc2Signal;
+    Res: IMyc2Condition;
+begin
+    for i := 0 to Count - 1 do
+    begin
+        Sig := Getter( i );
+        if not IsStatic( Sig ) then
+        begin
+            Res := TMyc2Condition.Create;
+
+            Sig.Advise( Res );
+
+            for j := i + 1 to Count - 1 do
+            begin
+                Sig := Getter( j );
+                if not IsStatic( Sig ) then
+                    Sig.Advise( Res );
+            end;
+
+            exit( Res.State );
+        end;
+    end;
+
+    exit( Null.State );
+end;
+
+class constructor TMyc2Signal.CreateClass;
+begin
+    FNull := TMyc2NullSink.Create;
+end;
+
+class destructor TMyc2Signal.DestroyClass;
+begin
+    FNull := nil;
+end;
+
+class function TMyc2Signal.IsStatic( const Signal: IMyc2Signal ): Boolean;
+begin
+    Result := ( Signal = nil ) or ( Signal = FNull.State );
+end;
+
+class function TMyc2Signal.MakeValid( const Signal: IMyc2Signal ): IMyc2Signal;
+begin
+    Result := Signal;
+    if Result = nil then
+        Result := Null.State;
+end;
+
+function TMyc2Signal.Advise( const Sink: IMyc2Sink ): TSignalTag;
+begin
+    if IsStatic( Sink ) then
+        exit( 0 );
+
+    FList.Lock;
+    try
+        Result := FList.Advise( Sink );
+
+        if IsSet then
+            Sink.Notify;
+    finally
+        FList.Release;
+    end;
+end;
+
+class function TMyc2Signal.CreateConcat( const States: array of IMyc2State ): IMyc2State;
+
+    function CreatePair( const A, B: IMyc2State ): IMyc2State;
+    var
+        Counter: IMyc2Condition;
+    begin
+        if A=B then
+        begin
+            Result := A;
+        end
+        else if IsStatic( A ) then
+        begin
+            if IsStatic( B ) then
+                Result := Signals.Null.State
+            else
+                Result := B;
+        end
+        else if IsStatic( B ) then
+        begin
+            Result := A;
+        end
+        else
+        begin
+            Counter := CreateCounter( 2 );
+            A.Advise( Counter );
+            B.Advise( Counter );
+            Result := Counter.State;
+        end;
+    end;
+
+    function CreateSet( const States: array of IMyc2State ): IMyc2State;
+    var
+        Counter: IMyc2Condition;
+        i, n: Integer;
+    begin
+        n := 0;
+        for i := 0 to High( States ) do
+            if not IsStatic( States[i] ) then
+                inc( n );
+
+        Counter := CreateCounter( n );
+        for i := 0 to High( States ) do
+            if not IsStatic( States[i] ) then
+                States[i].Advise( Counter );
+
+        Result := Counter.State;
+    end;
+
+begin
+    {TODO -oMS: Potentielles Speicherloch. Im Gegensatz zur Union werden hier die States nicht explizit un-advised. Andererseits
+     kann man eigentlich davon ausgehen, das States im Gegensatz zu einfachen Notifications irgendwann gesetzt und dann aufgeräumt
+     werden. Im Auge behalten! }
+
+    case Length( States ) of
+    0:
+        Result := Signals.Null.State;
+    1:
+        Result := States[0];
+    2:
+        Result := CreatePair( States[0], States[1] );
+    else
+        Result := CreateSet( States );
+    end;
+end;
+
+class function TMyc2Signal.CreateCounter( Count: Integer ): IMyc2Condition;
+begin
+    Assert( Count >=0 );
+
+    if Count > 0 then
+        Result := TMyc2CountSignal.Create( Count )
+    else
+        Result := Null;
+end;
+
+class function TMyc2Signal.CreateEvent( Init: Boolean ): IMyc2Event;
+begin
+    Result := TMyc2Event.Create( Init )
+end;
+
+class function TMyc2Signal.CreateGroup( Count: Integer; const Getter: TFunc<Integer, IMyc2Signal> ): IMyc2Signal;
+var
+    i, n: Integer;
+    Sigs: TArray<IMyc2Signal>;
+    Res: IMyc2Condition;
+begin
+    if Count = 0 then
+        exit( Null.State );
+
+    SetLength( Sigs, Count );
+    n := 0;
+    for i := 0 to Count - 1 do
+    begin
+        Sigs[n] := Getter( i );
+        if not IsStatic( Sigs[n] ) then
+            inc( n );
+    end;
+
+    if n = 0 then
+        exit( Null.State );
+
+    Res := CreateCounter( n );
+    for i := 0 to n - 1 do
+        Sigs[i].Advise( Res );
+
+    exit( Res.State );
+end;
+
+class function TMyc2Signal.CreateNotifier: IMyc2Notifier;
+begin
+    Result := TMyc2Notifier.Create;
+end;
+
+class function TMyc2Signal.MakeValid( const Signals: array of IMyc2Signal ): TArray<IMyc2Signal>;
+var
+    i, n: Integer;
+begin
+    n := 0;
+    for i := 0 to High( Signals ) do
+        if not IsStatic( Signals[i] ) then
+            inc( n );
+
+    SetLength( Result, n );
+    n := 0;
+    for i := 0 to High( Signals ) do
+        if not IsStatic( Signals[i] ) then
+        begin
+            Result[n] := Signals[i];
+            inc( n );
+        end;
+end;
+
+class function TMyc2Signal.CreateUnion( const Sigs: array of IMyc2Signal ): IMyc2Signal;
+begin
+    case Length( Sigs ) of
+    0:
+        Result := Signals.Null.State;
+    1:
+        Result := Sigs[0];
+    else
+        Result := TMycSignalUnion.Create( Sigs );
+    end;
+end;
+
+function TMyc2Signal.DoNotify: Boolean;
+begin
+    FList.Notify;
+    exit( true );
+end;
+
+function TMyc2Signal.GetIsSet: Boolean;
+begin
+    Result := true;
+end;
+
+class function TMyc2Signal.IsStatic( const Sink: IMyc2Sink ): Boolean;
+begin
+    Result := ( Sink = nil ) or ( Sink = FNull );
+end;
+
+function TMyc2Signal.Notify: Boolean;
+begin
+    FList.Lock;
+    try
+        Result := DoNotify;
+        if not Result then
+            FList.Finalize;
+    finally
+        FList.Release;
+    end;
+end;
+
+procedure TMyc2Signal.Unadvise( Tag: TSignalTag );
+begin
+    if Tag=0 then
+        exit;
+
+    FList.Lock;
+    try
+        FList.Unadvise( Tag );
+    finally
+        FList.Release;
+    end;
+end;
+
+{ TMyc2Event }
+
+constructor TMyc2Event.Create( AInit: Boolean );
+begin
+    inherited Create;
+    if AInit then
+        inc( FValue );
+end;
+
+function TMyc2Event.GetIsSet: Boolean;
+begin
+    Result := FValue <> 0;
+end;
+
+function TMyc2Event.DoNotify: Boolean;
+begin
+    if TInterlocked.Exchange( FValue, 1 ) = 0 then
+        inherited;
+    exit( true );
+end;
+
+function TMyc2Event.Reset: Boolean;
+begin
+    Result := TInterlocked.Exchange( FValue, 0 ) = 1;
+end;
+
+{ TMyc2CountownSignal }
+
+constructor TMyc2CountSignal.Create( ACount: Integer );
+begin
+    inherited Create;
+    FCount := ACount;
+end;
+
+function TMyc2CountSignal.GetIsSet: Boolean;
+begin
+    Result := FCount <= 0;
+end;
+
+function TMyc2CountSignal.DoNotify: Boolean;
+var
+    n: Integer;
+begin
+    n := TInterlocked.Decrement( FCount );
+    if n < -MaxInt div 2 then
+        TInterlocked.Increment( FCount );
+
+    if n = 0 then
+        inherited;
+
+    Result := n > 0;
+end;
+
+{ TMyc2SinkProc }
+
+constructor TMyc2SinkProc.Create( AOnce: Boolean; const AProc: TProc );
+begin
+    inherited Create;
+    FProc := AProc;
+    FOnce := AOnce;
+end;
+
+class function TMyc2SinkProc.CreateSink( Once: Boolean; const Proc: TProc ): IMyc2Sink;
+begin
+    if Assigned( Proc ) then
+        Result := TMyc2SinkProc.Create( Once, Proc )
+    else
+        Result := TMyc2Signal.Null;
+end;
+
+function TMyc2SinkProc.Notify: Boolean;
+begin
+    if Assigned( FProc ) then
+    begin
+        FProc( );
+        if FOnce then
+            FProc := nil;
+    end;
+
+    Result := Assigned( FProc );
+end;
+
+{ TMyc2NullState }
+
+function TMyc2NullState.Advise( const Sink: IMyc2Sink ): TSignalTag;
+begin
+    Sink._AddRef;
+    try
+        Sink.Notify;
+    finally
+        Sink._Release;
+    end;
+    exit( 0 );
+end;
+
+function TMyc2NullState.GetIsSet: Boolean;
+begin
+    exit( true );
+end;
+
+procedure TMyc2NullState.Unadvise( Tag: TSignalTag );
+begin
+end;
+
+procedure TMyc2NullState.UnadviseAll;
+begin
+
+end;
+
+constructor TMyc2NullSink.Create;
+begin
+    inherited Create;
+    FState := TMyc2NullState.Create;
+end;
+
+destructor TMyc2NullSink.Destroy;
+begin
+    inherited Destroy;
+end;
+
+function TMyc2NullSink.GetState: IMyc2State;
+begin
+    Result := FState;
+end;
+
+function TMyc2NullSink.Notify: Boolean;
+begin
+    Result := false;
+end;
+
+{ TMyc2Notifier }
+
+function TMyc2Notifier.GetSignal: IMyc2Signal;
+begin
+    Result := Self;
+end;
+
+{ TMyc2Condition }
+
+function TMyc2Condition.GetState: IMyc2State;
+begin
+    Result := Self;
+end;
+
+{ TMycSinkList }
+
+class constructor TMycSinkList.CreateClass;
+begin
+    FItems := TMycAtomicStack<TItem>.Create;
+    FPendingCnt := 0;
+    FUsedCnt := 0;
+end;
+
+class destructor TMycSinkList.DestroyClass;
+begin
+    Assert( FUsedCnt = 0 );
+    Assert( FPendingCnt = 0 );
+
+    FItems.Free;
+end;
+
+procedure TMycSinkList.Create;
+begin
+    FFirst := 1;
+    FList := nil;
+    {$ifdef DEBUG_SIGNALS}
+    FCount := 0;
+    {$endif}
+end;
+
+procedure TMycSinkList.Destroy;
+begin
+    // Because refcounting is thread-safe, this will always be entered once after all references
+    // to Self are dropped. No locking needed!
+    Assert( not IsLocked, 'Signal must not be locked!' );
+    FFirst := FFirst and not 3;
+    UnadviseAll;
+end;
+
+function TMycSinkList.Advise( const Sink: IMyc2Sink ): TSignalTag;
+var
+    Item: PItem;
+begin
+    Assert( IsLocked, 'Signal has to be locked' );
+
+    if IsFinalized then
+        exit( 0 );
+
+    {$ifdef DEBUG_SIGNALS}
+    inc( FCount );
+    Assert( FCount < 40000 );
+    {$endif}
+    if FFirst=0 then
+    begin
+        IMyc2Sink( FFirst ) := Sink;
+        exit( TSignalTag( Sink ) );
+    end;
+
+    Item := AllocItem;
+    Item.Sink := Sink;
+    Item.Prev := nil;
+    Item.Next := FList;
+    if Item.Next<>nil then
+        Item.Next.Prev := Item;
+
+    FList := Item;
+
+    exit( TSignalTag( Item ) );
+end;
+
+procedure TMycSinkList.Lock;
+begin
+    repeat
+        if FFirst and 1 = 0 then
+        begin
+            YieldProcessor;
+            continue;
+        end;
+    until TInterlocked.BitTestAndClear( PInteger( @FFirst )^, 0 );
+
+    Assert( IsLocked, 'Locking failed' );
+end;
+
+procedure TMycSinkList.Notify;
+var
+    Item, P: PItem;
+begin
+    Assert( IsLocked, 'Signal has to be locked' );
+
+    if IsFinalized then
+        exit;
+
+    if FFirst<>0 then
+        if not IMyc2Sink( FFirst ).Notify then
+            IMyc2Sink( FFirst ) := nil;
+
+    Item := FList;
+    while Item<>nil do
+    begin
+        P := Item.Next;
+        if not Item.Sink.Notify then
+            Unadvise( TSignalTag( Item ) );
+        Item := P;
+    end;
+end;
+
+class function TMycSinkList.AllocItem: PItem;
+begin
+    GetMem( Result, sizeof( TItem ) );
+    Pointer( Result.Sink ) := nil;
+end;
+
+procedure TMycSinkList.Finalize;
+begin
+    Assert( IsLocked, 'Signal has to be locked' );
+    UnadviseAll;
+    FFirst := FFirst or 2;
+end;
+
+class procedure TMycSinkList.FreeItem( Item: PItem );
+begin
+    FreeMem( Item, sizeof( TItem ) );
+end;
+
+function TMycSinkList.IsLocked: Boolean;
+begin
+    Result := FFirst and 1 = 0;
+end;
+
+function TMycSinkList.IsFinalized: Boolean;
+begin
+    Result := FFirst and 2 <> 0;
+end;
+
+procedure TMycSinkList.Release;
+begin
+    Assert( IsLocked, 'Signal not locked' );
+    TInterlocked.Exchange( Pointer( FFirst ), Pointer( FFirst or 1 ) );
+end;
+
+procedure TMycSinkList.Unadvise( Tag: TSignalTag );
+var
+    Item: PItem;
+begin
+    Assert( IsLocked, 'Signal not locked' );
+
+    if IsFinalized then
+        exit;
+
+    {$ifdef DEBUG_SIGNALS}
+    dec( FCount );
+    {$endif}
+    if Tag = FFirst then
+    begin
+        IMyc2Sink( FFirst ) := nil;
+        exit;
+    end;
+
+    Item := PItem( Tag );
+
+    if Item = FList then
+        FList := Item.Next;
+
+    if Item.Prev<>nil then
+        Item.Prev.Next := Item.Next;
+    if Item.Next<>nil then
+        Item.Next.Prev := Item.Prev;
+
+    Item.Sink := nil;
+
+    FreeItem( Item );
+end;
+
+procedure TMycSinkList.UnadviseAll;
+begin
+    Assert( IsLocked, 'Signal has to be locked' );
+
+    if IsFinalized then
+        exit;
+
+    IMyc2Sink( FFirst ) := nil;
+    while FList<>nil do
+        Unadvise( TSignalTag( FList ) );
+end;
+
+{ TMycObserver<T> }
+
+class function TMycObserver<T>.CreateObserver( const Signals: array of IMyc2Signal; const Item: T ): IMycObserver<T>;
+var
+    Arr: TArray<IMyc2Signal>;
+begin
+    {$message hint 'Design-Fehler!! Der Null-Observer ist nicht statisch!!'}
+    if Length( Signals ) = 0 then
+        Result := TNull.Create( Item )
+    else if ( Length( Signals )=1 ) and not TMyc2Signal.IsStatic( Signals[0] ) then
+        Result := TOne.Create( Signals[0], Item )
+    else
+    begin
+        Arr := TMyc2Signal.MakeValid( Signals );
+        if Arr = nil then
+            Result := TNull.Create( Item )
+        else if Length( Arr )=1 then
+            Result := TOne.Create( Arr[0], Item )
+        else
+            Result := TArr.Create( Arr, Item );
+    end;
+end;
+
+{ TMycObserver<T>.TNull }
+
+constructor TMycObserver<T>.TNull.Create( const ASink: T );
+begin
+    inherited Create;
+    FSink := ASink;
+end;
+
+function TMycObserver<T>.TNull.GetItem: T;
+begin
+    Result := FSink;
+end;
+
+{ TMycObserver<T>.TOne }
+
+constructor TMycObserver<T>.TOne.Create( const ASignal: IMyc2Signal; const ASink: T );
+begin
+    inherited Create( ASink );
+    FSignal := ASignal;
+    FTag := FSignal.Advise( FSink );
+end;
+
+destructor TMycObserver<T>.TOne.Destroy;
+begin
+    FSignal.Unadvise( FTag );
+    inherited;
+end;
+
+{ TMycObserver<T>.TArr }
+
+constructor TMycObserver<T>.TArr.Create( const ASignals: TArray<IMyc2Signal>; const ASink: T );
+var
+    i: Integer;
+begin
+    inherited Create( ASink );
+    FSignals := ASignals;
+
+    SetLength( FTags, Length( FSignals ) );
+    for i := 0 to High( FTags ) do
+    begin
+        if not Signals.IsStatic( FSignals[i] ) then
+            FTags[i] := FSignals[i].Advise( FSink )
+        else
+            FTags[i] := 0;
+    end;
+end;
+
+destructor TMycObserver<T>.TArr.Destroy;
+var
+    i: Integer;
+begin
+    for i := High( FSignals ) downto 0 do
+        if FTags[i]<>0 then
+            FSignals[i].Unadvise( FTags[i] );
+    inherited;
+end;
+
+{ TMycSignalUnion }
+
+constructor TMycSignalUnion.Create( const ASignals: array of IMyc2Signal );
+var
+    i: Integer;
+begin
+    inherited Create;
+
+    FNotifier := Signals.CreateNotifier;
+    SetLength( FTags, Length( ASignals ) );
+    SetLength( FSignals, Length( ASignals ) );
+    for i := 0 to High( FSignals ) do
+    begin
+        FSignals[i] := ASignals[i];
+        FTags[i] := FSignals[i].Advise( FNotifier );
+    end;
+end;
+
+destructor TMycSignalUnion.Destroy;
+var
+    i: Integer;
+begin
+    for i := High( FTags ) downto 0 do
+        FSignals[i].Unadvise( FTags[i] );
+
+    inherited;
+end;
+
+function TMycSignalUnion.Advise( const Sink: IMyc2Sink ): TSignalTag;
+begin
+    Result := FNotifier.Signal.Advise( Sink );
+end;
+
+procedure TMycSignalUnion.Unadvise( Tag: TSignalTag );
+begin
+    FNotifier.Signal.Unadvise( Tag );
+end;
+
+{ TMyc2Flag }
+
+constructor TMyc2Flag.Create( AFlag: Boolean );
+begin
+    inherited Create;
+    FFlag := Integer( AFlag );
+end;
+
+function TMyc2Flag.Notify: Boolean;
+begin
+    Result := TInterlocked.Exchange( FFlag, 1 ) = 0;
+end;
+
+function TMyc2Flag.Reset: Boolean;
+begin
+    Result := TInterlocked.Exchange( FFlag, 0 ) = 1;
+end;
+
+end.
diff --git a/Src/Myc.pas b/Src/Myc.pas
new file mode 100644
index 0000000..12dd378
--- /dev/null
+++ b/Src/Myc.pas
@@ -0,0 +1,3848 @@
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+///
+///  Mycelium Scenes Library
+///  -----------------------
+///
+///  (c)2007-2020 Michael Schimmel
+///               Ehrenhainstr 40
+///               42329 Wuppertal / Germany
+///               info@mycelium.net
+///
+///  All rights reserved.
+///
+//////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+unit Myc;
+
+interface
+
+uses
+    {$ifdef FullDebugMode}FastMM5, {$endif}
+    System.SysUtils, System.TypInfo, System.Generics.Collections,
+    System.Generics.Defaults;
+
+{$minenumsize 4}
+
+
+type
+    {$message hint 'Debug-Code! Const Params?'}
+    TMyc3Combiner<T, V> = reference to function( const Values: TArray<V> ): T;
+
+    TMyc3Interpolator<T> = reference to function( Delta: Double; const StartValue: T; out Value: T ): Boolean;
+    TMyc3TargetInterpolator<T> = reference to function( Delta: Double; const StartValue, TargetValue: T; out Value: T ): Boolean;
+
+    EMycInvalidParameter = class( Exception )
+    end;
+
+    EMycInvalidOperation = class( Exception )
+    end;
+
+    TConstFunc<A, T> = reference to function( const aa: A ): T;
+    TConstFunc<A, B, T> = reference to function( const aa: A; const bb: B ): T;
+    TConstFunc<A, B, C, T> = reference to function( const aa: A; const bb: B; const cc: C ): T;
+    TConstFunc<A, B, C, D, T> = reference to function( const aa: A; const bb: B; const cc: C ; const dd: D ): T;
+    TConstFunc<A, B, C, D, E, T> = reference to function( const aa: A; const bb: B; const cc: C ; const dd: D; const ee: E ): T;
+    TConstProc<A> = reference to procedure( const aa: A );
+    TConstProc<A, B> = reference to procedure( const aa: A; const bb: B );
+    TConstProc<A, B, C> = reference to procedure( const aa: A; const bb: B; const cc: C );
+
+    TCompareValues<T> = reference to function( const A, B: T ): Boolean;
+
+    /////////////////////////////////////////////////////////////////////////////
+
+    IMycEnumerator<T> = interface
+        function GetCurrent: T;
+        function MoveNext: Boolean;
+        procedure Reset;
+        property Current: T read GetCurrent;
+    end;
+
+    IMyc2Enumerable<T> = interface
+        function GetEnumerator: IMycEnumerator<T>;
+    end;
+
+    IMycCountable<T> = interface
+        {$region 'property access'}
+        function GetCount: Integer;
+        function GetItems( Idx: Integer ): T;
+        {$endregion}
+        property Count: Integer read GetCount;
+        property Items[Idx: Integer]: T read GetItems; default;
+    end;
+
+    /////////////////////////////////////////////////////////////////////////////
+
+    IAtomicStack<T> = interface
+        function Pop: T;
+        function TryPop( out Item: T ): Boolean;
+        procedure Push( const Data: T );
+    end;
+
+    TAtomicStack<T> = record
+        class function Create: IAtomicStack<T>; static;
+    end;
+
+    TProtected<T: IInterface> = record
+    private
+        [volatile]
+        FItem: T;
+
+    public
+        constructor Create( const AItem: T );
+        function Exchange( const Value: T ): T;
+        class operator Implicit( const Value: T ): TProtected<T>;
+    end;
+
+    /////////////////////////////////////////////////////////////////////////////
+
+    IMyc2Sink = interface
+        function Notify: Boolean;
+    end;
+
+    IMyc2Flag = interface( IMyc2Sink )
+        function Reset: Boolean;
+    end;
+
+    {$message hint 'Replace TSignalTag by IMycDeletable? '}
+    TSignalTag = NativeInt;
+
+    IMyc2Signal = interface
+        function Advise( const Sink: IMyc2Sink ): TSignalTag;
+        procedure Unadvise( Tag: TSignalTag );
+    end;
+
+    IMyc2Notifier = interface( IMyc2Sink )
+        {$region 'property access'}
+        function GetSignal: IMyc2Signal;
+        {$endregion}
+        property Signal: IMyc2Signal read GetSignal;
+    end;
+
+    IMyc2State = interface( IMyc2Signal )
+        {$region 'property access'}
+        function GetIsSet: Boolean;
+        {$endregion}
+        property IsSet: Boolean read GetIsSet;
+    end;
+
+    IMyc2Condition = interface( IMyc2Sink )
+        {$region 'property access'}
+        function GetState: IMyc2State;
+        {$endregion}
+        property State: IMyc2State read GetState;
+    end;
+
+    IMyc2Event = interface( IMyc2Condition )
+        function Reset: Boolean;
+    end;
+
+    IMycObserver<T: IMyc2Sink> = interface
+        function GetItem: T;
+        property Item: T read GetItem;
+    end;
+
+    IMycNotifyObserver = IMycObserver<IMyc2Notifier>;
+    IMycEventObserver = IMycObserver<IMyc2Event>;
+
+    TMycStateQueue = record
+    private
+        FStack: IAtomicStack<IMyc2State>;
+
+    public
+        constructor Create(const AStack: IAtomicStack<IMyc2State>); overload;
+
+        class function Create: TMycStateQueue; overload; static;
+
+        procedure Add( const S: IMyc2State );
+        procedure WaitFor;
+
+    end;
+
+    Signals = record
+    private
+        class function GetNull: IMyc2Condition; static;
+
+    public
+        class function CreateCounter( Count: Integer ): IMyc2Condition; static;
+        class function CreateEvent( Init: Boolean = false ): IMyc2Event; overload; static;
+        class function CreateNotifier: IMyc2Notifier; overload; static;
+        class function CreateSink(Once: Boolean; const Proc: TProc): IMyc2Sink; overload; static; deprecated;
+        class function CreateSink(const Proc: TProc): IMyc2Sink; overload; static;
+        class function CreateFlag(Init: Boolean): IMyc2Flag; static;
+
+        class function CreateObserver<T: IMyc2Sink>( const Signals: array of IMyc2Signal; const Sink: T ): IMycObserver<T>; static;
+        class function CreateNotifyObserver( const Signals: array of IMyc2Signal ): IMycNotifyObserver; overload; static;
+        class function CreateEventObserver( const Signals: array of IMyc2Signal ): IMycEventObserver; overload; static;
+
+        class function CreateNotifyObserver( const Signals: IMycCountable<IMyc2Signal> ): IMycNotifyObserver; overload; static;
+        class function CreateEventObserver( const Signals: IMycCountable<IMyc2Signal> ): IMycEventObserver; overload; static;
+
+        class function Concat( const States: array of IMyc2State ): IMyc2State; static;
+        class function Union( const Sigs: array of IMyc2Signal ): IMyc2Signal; static;
+
+        class function IsStatic( const Signal: IMyc2Signal ): Boolean; static; inline;
+        class function MakeValid( const Signal: IMyc2Signal ): IMyc2Signal; overload; static; inline;
+        class function MakeValid( const Signals: array of IMyc2Signal ): TArray<IMyc2Signal>; overload; static;
+
+        class property Null: IMyc2Condition read GetNull;
+    end;
+
+    /////////////////////////////////////////////////////////////////////////////
+
+    IMyc3Value<T> = interface
+        {$region 'property access'}
+        function GetValue: T;
+        {$endregion}
+        property Value: T read GetValue;
+    end;
+
+    TImmutable<T> = record
+    private
+        FThis: IMyc3Value<T>;
+        function GetValue: T; inline;
+        function GetHasValue: Boolean; inline;
+        class function GetNull: TImmutable<T>; static; inline;
+    public
+        constructor Create(const AValue: T); overload;
+        class operator NotEqual(ALeft, ARight: TImmutable<T>): Boolean;
+        class operator Equal(ALeft, ARight: TImmutable<T>): Boolean;
+        property Value: T read GetValue;
+        property HasValue: Boolean read GetHasValue;
+        class property Null: TImmutable<T> read GetNull;
+    end;
+
+    // IDEA:
+    // Mutable objects represent exactly *one* property of a dynamic system.
+    // As such, they provide a change signal and an immutable value
+    // that is *replaced*, when they change.
+    // Q: How do you maintain thread safety with such an object?
+    // A: Reading a mutable object needs locking. There's no way around it.
+    //    But picking up a reference to an immutable can be done with almost no
+    //    overhead using atomic operations.
+    //    Given the nature of mutable objects, they should only be used within
+    //    the scope of a single thread (which does not have to be the main thread!)
+    // Q: Is it getting any better this way?
+    // A: mmmh... at least it offloads the application from doing this kinda stuff.
+    //    And it ensures separating data from logic.
+    // Q: Shouldn't IMutable then be derived from IValue<T> or from ISignal?
+    // A: To be considered. Given that IMutable is *not* the value itself, because
+    //    IValue is immutable by definition, it seems to make more sense to derive
+    //    it from ISignal. OTOH, it isn't a signal either. Maybe it should really
+    //    stand for it's own.
+
+    // Mutable objects may change over time.
+    IMyc3Mutable = interface
+        {$region 'property access'}
+        function GetChanged: IMyc2Signal;
+        {$endregion}
+        property Changed: IMyc2Signal read GetChanged;
+    end;
+
+    // The Values of typed mutable objects are typed immutables. (And thus should
+    // be IValue<T> instead of T, see idea above).
+    IMyc3Mutable<T> = interface( IMyc3Mutable )
+        {$region 'property access'}
+        function GetValue: T;
+        {$endregion}
+        property Value: T read GetValue;
+    end;
+
+    IMyc3ObjectLink<T: class> = interface
+        {$region 'property access'}
+        function GetMutable: IMyc3Mutable<T>;
+        {$endregion}
+        procedure Destroyed;
+        property Mutable: IMyc3Mutable<T> read GetMutable;
+    end;
+
+    IMyc3Validatable = interface
+        {$region 'property access'}
+        function GetInvalidate: IMyc2Signal;
+        {$endregion}
+
+        function Validate: Boolean;
+        property Invalidate: IMyc2Signal read GetInvalidate;
+    end;
+
+    IMyc3Validatable<T> = interface( IMyc3Validatable )
+        {$region 'property access'}
+        function GetValue: T;
+        {$endregion}
+        property Value: T read GetValue;
+    end;
+
+    TValidatable = record
+        class function FromSignal(const Signal: IMyc2Signal): IMyc3Validatable; static;
+    end;
+
+    // This is the generic base interface for futures. Futures are used to initialize
+    // and hold immutable data.
+    //
+    // After the initialization is finished, the future and its value are considered
+    // to be immutable, which means statically constant and accessing them is always
+    // thread-safe and non-blocking.
+    //
+    // Reading the data before initialization is finished is not allowed! Other
+    // threads have to wait for the initialization signal before accessing the value.
+    // This can be done explicitly by waiting or by pipelining other futures.
+    IMyc3Future<T> = interface
+
+        {$region 'property access'}
+        function GetInitialized: IMyc2State;
+        function GetValue: T;
+        {$endregion}
+        // Wait until initialization is finished. Being a blocking operation, this is only
+        // allowed from the main thread.
+        {$message hint 'Sollte nichts zurückgeben, damit es nicht in Conditionals verwendet wird!'}
+        function WaitFor: T;
+
+        // Initialization state. This state is set exactly once in the lifetime of the
+        // future. It can be used to pipeline other futures.
+        //
+        property Initialized: IMyc2State read GetInitialized;
+
+        // Reading the value is NOT ALLOWED until the initialization is finished,
+        // otherwise an exception is raised.
+        //
+        // Use [WaitFor] to block execution until the value is ready.
+        property Value: T read GetValue;
+    end;
+
+    IMyc3Changeable<T> = interface
+        {$region 'property access'}
+        function GetMutable: IMyc3Mutable<T>;
+        {$endregion}
+        procedure SetChanged;
+        property Mutable: IMyc3Mutable<T> read GetMutable;
+    end;
+
+    IMyc3Generic<T> = interface( IMyc3Changeable<T> )
+        {$region 'property access'}
+        function GetFunc: TFunc<T>;
+        procedure SetFunc(const Value: TFunc<T>);
+        {$endregion}
+        property Func: TFunc<T> read GetFunc write SetFunc;
+    end;
+
+    IMyc3Writeable<T> = interface( IMyc3Changeable<T> )
+        function SetValue(const Value: T): Boolean;
+    end;
+
+    IMyc3ValidateMutable<T> = interface( IMyc3Mutable<T> )
+        procedure Validate;
+    end;
+
+    IMyc3Property<T> = interface( IMyc3Mutable<T> )
+        procedure Delete; overload;
+        procedure Delete( const DefaultValue: T ); overload;
+    end;
+
+    IMyc3MutableProperty<T> = interface( IMyc3Mutable<T> )
+
+        {$region 'property access'}
+        procedure SetMutable( const Value: IMyc3Mutable<T> );
+        {$endregion}
+        property Mutable: IMyc3Mutable<T> write SetMutable;
+    end;
+
+    IMyc3MutablePropertyEx<T> = interface( IMyc3Mutable<T> )
+        procedure Invalidate;
+    end;
+
+    IMyc3Animator = interface
+        procedure Tick( const Ticks: Int64 );
+    end;
+
+    IMyc3Animator<T> = interface( IMyc3Animator )
+        function GetCurrent: IMyc3Mutable<T>;
+        property Current: IMyc3Mutable<T> read GetCurrent;
+    end;
+
+    IMycDeletable = interface
+        procedure Delete;
+    end;
+
+    IMycArray<T> = interface( IMyc2Enumerable<T> )
+        {$region 'property access'}
+        function GetCount: Integer;
+        function GetItems( Idx: Integer ): T;
+        {$endregion}
+        function ToArray: TArray<T>;
+        function Sort( const Comparer: IComparer<T> = nil; First: Integer = 0; Count: Integer = -1 ): TArray<Integer>;
+        function Divide( const Comparer: IComparer<T> ): TArray<IMycArray<T>>;
+        function Divide1( const Comparer: IComparer<T> ): TArray<TArray<Integer>>;
+        function Range( First: Integer; Count: Integer ): IMycArray<T>;
+        function Rearrange( const Indices: TArray<Integer> ): IMycArray<T>;
+        property Count: Integer read GetCount;
+        property Items[Idx: Integer]: T read GetItems; default;
+    end;
+
+    IMycChain<T> = interface( IMyc2Enumerable<T> )
+        {$region 'property access'}
+        function GetChanged: IMyc2Signal;
+        {$endregion}
+        function AddFirst( const Item: T ): IMycDeletable;
+        function AddLast( const Item: T ): IMycDeletable;
+        function ToArray: TArray<T>;
+        property Changed: IMyc2Signal read GetChanged;
+    end;
+
+    TChain = record
+    public
+        class function Create<T>: IMycChain<T>; static;
+    end;
+
+    TMycArray = class {helper for TArray}
+    public
+        class function Create<T>( const Arr: array of T ): IMycArray<T>; overload; static;
+        class function Create<T>( Count: Integer; const Getter: TFunc<Integer, T> ): IMycArray<T>; overload; static;
+
+        class function Create<T>(const Src: IMyc2Enumerable<T>): IMycArray<T>; overload; static;
+
+        class function Create<S, T>( const Src: IMycArray<S>; const Converter: TConstFunc<S, T> ): IMycArray<T>; overload; static;
+
+        class procedure Divide1<TKey, TValue>( const Src: IMycArray<TPair<TKey, TValue>>; out Keys: TArray<TKey>; out Values:
+                TArray<IMycArray<TValue>>; const Comparer: IComparer<TKey> ); overload; static;
+
+        class function Divide<TKey, TValue>( const Src: IMycArray<TPair<TKey, TValue>>; const Comparer: IComparer<TKey> ): TArray<TPair<TKey,
+            IMycArray<TValue>>>; overload; static;
+
+        class function Divide<T>( const Src: TArray<T>; const Comparer: IComparer<T> ): TArray<TArray<T>>; overload; static;
+        class function Divide<TKey, TValue>( const Src: TArray<TPair<TKey, TValue>>; const Comparer: IComparer<TKey> ): TArray<TPair<TKey,
+            TArray<TValue>>>; overload; static;
+
+        class function GetKeys<TKey, TValue>( const Arr: TArray<TPair<TKey, TValue>> ): TArray<TKey>; static;
+
+        class function CreateConvert<T, S>( const Enum: IMyc2Enumerable<S>; const Conv: TConstFunc<S, T> ): IMyc2Enumerable<T>;
+    end;
+
+    IMyc3Set<S, T> = interface( IMyc3Mutable<T> )
+        function Add( const Item: S ): Integer;
+        procedure Remove( const Item: S );
+        procedure Delete( Idx: Integer );
+        procedure Clear;
+    end;
+
+    IMycEnumerable<T> = interface( IMyc3Mutable<TArray<T>> )
+        {$region 'property access'}
+        function GetCount: Integer;
+        {$endregion}
+        function GetEnumerator: IMycEnumerator<T>;
+        property Count: Integer read GetCount;
+    end;
+
+    IMycSetItem<T> = interface( IMycDeletable )
+        {$region 'property access'}
+        function GetValue: T;
+        {$endregion}
+        property Value: T read GetValue;
+    end;
+
+    IMycSet<T> = interface( IMycEnumerable<T> )
+        function Add( const Value: T ): IMycSetItem<T>;
+        function Pop: T;
+        procedure Clear;
+    end;
+
+    IMycEnumArray<T> = interface( IMycEnumerable<T> )
+        {$region 'property access'}
+        function GetItems( Idx: Integer ): T;
+        {$endregion}
+        function Sort( const Comparer: IComparer<T> = nil; First: Integer = 0; Count: Integer = -1 ): IMycArray<T>;
+        property Items[Idx: Integer]: T read GetItems; default;
+    end;
+
+    TSet<T> = record
+    public
+        class function Create: IMycSet<T>; overload; static;
+        class function Create( const Arr: IMyc3Mutable<TArray<T>> ): IMycEnumArray<T>; overload; static;
+        class function CreateEx( const Arr: TArray<T> ): IMycEnumArray<T>; overload; static;
+    end;
+
+    IMycAssembly<T> = interface( IMycSet<IMyc3Mutable<TArray<T>>> )
+        {$region 'property access'}
+        function GetItems: IMyc3Mutable<TArray<T>>;
+        {$endregion}
+        function Add( const Value: T ): IMycDeletable; overload;
+        function Add( const Values: array of T ): IMycDeletable; overload;
+        property Items: IMyc3Mutable<TArray<T>> read GetItems;
+    end deprecated;
+
+    TAssembly<T> = record
+        class function Create: IMycAssembly<T>; static;
+    end deprecated;
+
+    IMycStack<T> = interface
+        {$region 'property access'}
+        function GetCount: Integer;
+        {$endregion}
+        procedure Push( const Value: T );
+        function Pop: T;
+        procedure Clear;
+        function ToArray: TArray<T>;
+        property Count: Integer read GetCount;
+    end;
+
+    Stack = record
+        class function Create<T>: IMycStack<T>; static;
+    end;
+
+    TFunc<U, V, W, X, Y, T> = reference to function( P1: U; P2: V; P3: W; P4: X; P5: Y ): T;
+    TFunc<U, V, W, X, Y, Z, T> = reference to function( P1: U; P2: V; P3: W; P4: X; P5: Y; P6: Z ): T;
+
+    /////////////////////////////////////////////////////////////////////////////
+    // TValue
+    //
+    TValue<T> = class
+    type
+        TCalculator = reference to procedure( var Value: T );
+
+    class var
+        FDefaultMutable: IMyc3Mutable<T>;
+        FDefaultMutableFuture: IMyc3Mutable<IMyc3Future<T>>;
+
+        class constructor CreateClass;
+        class function GetDefaultFuture: IMyc3Future<T>; static;
+
+    public
+        class function AsImmutable( const Value: T ): IMyc3Value<T>; overload; static;
+
+        class function CreateLazy(const Func: TFunc<T>): IMyc3Value<T>; static;
+
+        // Create a constant future.
+        class function AsFuture( const Value: T ): IMyc3Future<T>; static;
+
+        // Create a generic future. Its fully up to the calculator to handle
+        // synchronization.
+        class function CreateFuture( const StartSignal: IMyc2Signal; const Calculator: TFunc<T> ): IMyc3Future<T>;
+            overload; static;
+        class function CreateFuture( const StartSignal: IMyc2Signal; const Calculator: TFunc < IMyc3Future < T >> )
+            : IMyc3Future<T>; overload; static;
+
+        class function CreateFutureArray( Count: Integer; const Calculator: TFunc<Integer, T> ): IMyc3Future<TArray<T>>; overload; static;
+        class function CreateFutureArray( const StartSignal: IMyc2Signal; Count: Integer; const Calculator: TFunc<Integer, T> ):
+            IMyc3Future<TArray<T>>; overload; static;
+
+        class function CreateFutures( Count: Integer; const Src: IMyc3Future < TArray < T >> ): TArray<IMyc3Future<T>>; overload; static;
+
+        // Create a generic immutable
+        class function CreateFuture( const Calculator: TFunc<T> ): IMyc3Future<T>; overload; static;
+
+        class function Convert<S>( P: IMyc3Future<S>; const Converter: TFunc<S, T> ): IMyc3Future<T>; static;
+
+        // Create an immutable from one other immutables.
+        class function CreateFuture<U>( P: IMyc3Future<U>; Calculator: TFunc<U, T> ): IMyc3Future<T>; overload; static;
+        class function CreateFuture<U>( P: IMyc3Future<U>; Calculator: TFunc < U, IMyc3Future < T >> ): IMyc3Future<T>;
+            overload; static;
+        class function CreateFuture<U, V>( P1: IMyc3Future<U>; P2: IMyc3Future<V>; Calculator: TFunc<U, V, T> ): IMyc3Future<T>;
+            overload; static;
+        class function CreateFuture<U, V>( P1: IMyc3Future<U>; P2: IMyc3Future<V>; Calculator: TFunc < U, V, IMyc3Future < T >> )
+            : IMyc3Future<T>; overload; static;
+        class function CreateFuture<U, V, W>( P1: IMyc3Future<U>; P2: IMyc3Future<V>; P3: IMyc3Future<W>;
+            Calculator: TFunc<U, V, W, T> ): IMyc3Future<T>; overload; static;
+
+        // Create an immutable array from an array of immutables.
+        class function CreateFuture( const Values: TArray < IMyc3Future < T >> ): IMyc3Future<TArray<T>>; overload; static;
+        class function CreateFuture<S>( const Values: TArray<IMyc3Future<S>>; const Calculator: TFunc<Integer, S, T> ): IMyc3Future<TArray<T>>;
+            overload; static;
+
+        // Calculate an immutable from a set of other immutables. This is a convenient
+        // function that passes the parameter Values as typed array to the calculator.
+        class function CreateFuture<S>( const Params: TArray<IMyc3Future<S>>; Calculator: TFunc<TArray<S>, T> ): IMyc3Future<T>;
+            overload; static;
+
+        // Create a future from the value of another future.
+        class function CreateFuture( Future: IMyc3Future<T>; Creator: TFunc<T, IMyc3Future<T>> ): IMyc3Future<T>;
+            overload; static;
+
+        // Execute on future init.
+        class function Execute( Future: IMyc3Future<T>; Proc: TConstFunc<T, IMyc2Signal> ): IMyc2State;
+
+        // Get value, if future is initialized.
+        class function TryGetValue( const Future: IMyc3Future<T>; out Value: T ): Boolean; static;
+
+        // Create a mutable from a constant value. The resulting mutable never changes.
+        class function AsConst( const Value: T ): IMyc3Mutable<T>; overload; static; deprecated 'use TMutable<T>()';
+        class function CreateMutable( const Value: T ): IMyc3Mutable<T>; overload; static; deprecated 'use TMutable<T>()';
+
+        class function CreateMutable( Calculator: TFunc<T> ): IMyc3Mutable<T>; overload; static;
+        experimental;
+
+        class function CreateMutable( const Changed: array of IMyc2Signal; const Calculator: TFunc<T> ): IMyc3Mutable<T>; overload; static; deprecated 'use TMutable<T>.FromSignals()';
+        class function CreateMutable(const Changed: array of IMyc2Signal; const Calculator: TFunc<IMyc3Mutable<T>>): IMyc3Mutable<T>; overload; static; deprecated 'use TMutable<T>.FromSignals()';
+        // Extend a mutable by a set of signals.
+        class function CreateMutable( const Changed: array of IMyc2Signal; const Mutable: IMyc3Mutable<T> ): IMyc3Mutable<T>; overload; static;
+        class function CreateMutable( const Event: IMycEventObserver; const Calculator: TFunc<T> ): IMyc3Mutable<T>; overload; static;
+        // Futures as mutables
+        class function AsMutable( const Value: IMyc3Mutable<IMyc3Value<T>> ): IMyc3Mutable<T>; overload; static;
+        class function AsMutable( const Value: IMyc3Mutable<IMyc3Mutable<T>> ): IMyc3Mutable<T>; overload; static;
+
+        class function AsMutable(const Value: IMyc3Future<T>): IMyc3Mutable<T>; overload; static;
+        class function AsMutable(const Value: IMyc3Mutable<IMyc3Future<T>>): IMyc3Mutable<T>; overload; static;
+
+        // Operators
+        class function CreateMutable<U>( P: IMyc3Mutable<U>; Calculator: TFunc<U, T> ): IMyc3Mutable<T>; overload; static;
+        class function CreateMutable<U, V>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; Calculator: TFunc<U, V, T> )
+            : IMyc3Mutable<T>; overload; static;
+        class function CreateMutable<U, V, W>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>;
+            Calculator: TFunc<U, V, W, T> ): IMyc3Mutable<T>; overload; static;
+        class function CreateMutable<U, V, W, X>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>;
+            P4: IMyc3Mutable<X>; Calculator: TFunc<U, V, W, X, T> ): IMyc3Mutable<T>; overload; static;
+        class function CreateMutable<U, V, W, X, Y>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>; P4: IMyc3Mutable<X>; P5:
+                IMyc3Mutable<Y>; Calculator: TFunc<U, V, W, X, Y, T> ): IMyc3Mutable<T>; overload; static;
+        class function CreateMutable<U, V, W, X, Y, Z>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>; P4: IMyc3Mutable<X>; P5:
+                IMyc3Mutable<Y>; P6: IMyc3Mutable<Z>; Calculator: TFunc<U, V, W, X, Y, Z, T> ): IMyc3Mutable<T>; overload; static;
+
+        // Mutable arrays
+        class function CreateMutable( const Arr: TArray < IMyc3Mutable < T >> ): IMyc3Mutable<TArray<T>>; overload; static; deprecated 'Mutable<T>.CreateArray';
+        class function CreateMutable<S>( const Arr: TArray<IMyc3Mutable<S>>; Calculator: TFunc<Integer, S, T> ):
+            IMyc3Mutable<TArray<T>>; overload; static;
+        class function CreateMutableEx<S>( Params: TArray<IMyc3Mutable<S>>; Calculator: TFunc<TArray<S>, T> ): IMyc3Mutable<T>; overload; static;
+        experimental;
+
+        {$message hint 'Debug-Code! Eigentlich ist das hier das wahre Lazy-Mutable'}
+        class function CreateGeneric(const Calculator: TFunc<T> = nil): IMyc3Generic<T>;
+
+        // Create a mutable, that supports direct changes to it's value.
+        class function CreateWriteable: IMyc3Writeable<T>; overload; static;
+        class function CreateWriteable( const InitValue: T ): IMyc3Writeable<T>; overload; static;
+        class function CreateWriteable( const InitValue: T; const EqualityComparison: TEqualityComparison<T> ): IMyc3Writeable<T>;
+            overload; static;
+
+        class function CreateValidate( const Calculator: TFunc<T> ): IMyc3ValidateMutable<T>; static;
+
+        class function CreateMutableProperty(const InitValue: IMyc3Mutable<T> = nil): IMyc3MutableProperty<T>; overload; static; experimental;
+
+        class function CreateProperty( const Creator: TFunc < IMyc3Mutable < T >> ): IMyc3MutablePropertyEx<T>; overload; static;
+        experimental;
+
+        class function CreatePropertyEx( const Decorated: IMyc3Mutable<T> ): IMyc3Property<T>; overload; static;
+
+        // Combining values
+        class function Combine<V>( Values: TArray<V>; Combiner: TMyc3Combiner<T, V> ): IMyc3Future<T>; overload; static;
+        class function Combine<V>(const Values: TArray<IMyc3Mutable<V>>; Combiner: TMyc3Combiner<T, V>): IMyc3Mutable<T>; overload; static;
+        class function Combine<V>( const Values: TArray<IMyc3Future<V>>; Combiner: TMyc3Combiner<T, V> ): IMyc3Future<T>;
+            overload; static;
+        class function CreateSet: IMycSet<T>; overload; static;
+
+        class function WaitFor( Future: IMyc3Future<T> ): T; overload; static;
+        class procedure WaitFor( const Futures: TArray<IMyc3Future<T>>; Exec: TProc<Integer, T> ); overload; static;
+
+        class function Capture( const Src: TArray<T> ): TArray<T>;
+        experimental;
+
+        class function CreateAnimator( const Target: IMyc3Mutable<T>; const Interpolator: TMyc3TargetInterpolator<T> )
+            : IMyc3Animator<T>; overload; static;
+        class function CreateAnimator( const Init: T; const ChangeSignal: IMyc2Signal; const Interpolator: TMyc3Interpolator<T> )
+            : IMyc3Animator<T>; overload; static;
+
+        class function MakeValid( const Value: IMyc3Future<T> ): IMyc3Future<T>; overload; static; inline;
+        class function MakeValid( const Value: IMyc3Mutable<T> ): IMyc3Mutable<T>; overload; static; inline;
+
+        class property DefaultFuture: IMyc3Future<T> read GetDefaultFuture;
+        class property DefaultMutable: IMyc3Mutable<T> read FDefaultMutable;
+        class property DefaultMutableFuture: IMyc3Mutable<IMyc3Future<T>> read FDefaultMutableFuture;
+    end;
+
+    TMutableFuture<T> = record
+    private
+        class var
+            FNull: IMyc3Mutable<IMyc3Future<T>>;
+        class function GetNull: IMyc3Mutable<IMyc3Future<T>>; static;
+        class constructor CreateClass;
+
+    public
+        class function Create<S>( const P: IMyc3Mutable<IMyc3Future<T>>; Calc: TFunc<T, S> ): IMyc3Mutable<IMyc3Future<S>>; static;
+
+        class property Null: IMyc3Mutable<IMyc3Future<T>> read GetNull;
+    end;
+
+    IMyc3MutableCache<T> = interface( IMyc3Mutable )
+        {$region 'property access'}
+        function GetCount: Integer;
+        {$endregion}
+        function Add( const Value: IMyc3Mutable<T> ): IMyc3Mutable<T>;
+        procedure Clear;
+        procedure Validate;
+        function GetEnumerator: IMycEnumerator<IMyc3Mutable<T>>;
+        property Count: Integer read GetCount;
+    end;
+
+    IMyc3MutableTable = interface
+        procedure Clear;
+    end;
+
+    IMyc3MutableTable<T> = interface( IMyc3MutableTable )
+        function Add( const Value: T ): IMyc3Mutable<T>;
+    end;
+
+    TMutableCache<T> = record
+    private
+        FThis: IMyc3MutableTable<T>;
+
+        function GetItem(const Value: T): IMyc3Mutable<T>;
+
+    public
+        constructor Create( const AThis: IMyc3MutableTable<T> );
+        procedure Clear;
+        property Item[const Value: T]: IMyc3Mutable<T> read GetItem; default;
+    end;
+
+    TMutable<T> = record
+    private
+        FThis: IMyc3Mutable<T>;
+
+    public
+        class function FromSignals(const Changed: array of IMyc2Signal; const Calculator: TFunc<T>): IMyc3Mutable<T>; overload; static;
+        class function FromSignals(const Changed: array of IMyc2Signal; const Calculator: TFunc<IMyc3Mutable<T>>): IMyc3Mutable<T>; overload; static;
+
+        class function From<S>(const Value: IMyc3Mutable<S>; const Conv: TFunc<S, IMyc3Mutable<T>>): TMutable<T>; overload; static;
+
+        class operator Explicit(const Value: T): TMutable<T>;
+        class operator Implicit(const Item: IMyc3Mutable<T>): TMutable<T>;
+        class operator Implicit(const Item: TMutable<T>): IMyc3Mutable<T>;
+    end;
+
+    TMutableFuture = record
+
+        // Arrays
+        class function FromArray<T>(const Value: TArray<IMyc3Mutable<IMyc3Future<T>>>): IMyc3Mutable<IMyc3Future<TArray<T>>>; overload; static;
+    end;
+
+    TFuture = record
+        class function From<S, T>(const Value: IMyc3Future<S>; const Conv: TFunc<S, T>): IMyc3Future<T>; overload; static;
+        class function From<S, T>(const Value: IMyc3Future<S>; const Conv: TFunc<S, IMyc3Future<T>>): IMyc3Future<T>; overload; static;
+
+        class function FromArray<T>(const Value: TArray<IMyc3Future<T>>): IMyc3Future<TArray<T>>; overload; static;
+
+        class function Combine<S, T>( const Value: TArray<IMyc3Future<S>>; const Calculator: TFunc<TArray<S>, T> ): IMyc3Future<T>; overload; static;
+
+        class function Merge<T>(const Parts: TArray<TArray<T>>): TArray<T>; overload; static;
+        class function Merge<T>(const Parts: TArray<IMyc3Future<TArray<T>>>): IMyc3Future<TArray<T>>; overload; static;
+    end;
+
+    Mutable = record
+        // convert
+        class function Convert<S, T>(const Value: IMyc3Mutable<S>; const Conv: TFunc<S, T>): IMyc3Mutable<T>; overload; static;
+        class function Convert<S, T>(const Value: IMyc3Mutable<IMyc3Future<S>>; const Conv: TFunc<S, T>): IMyc3Mutable<IMyc3Future<T>>; overload; static;
+        class function Convert<S, T>(const Value: IMyc3Mutable<IMyc3Future<S>>; const Conv: TFunc<S, IMyc3Future<T>>): IMyc3Mutable<IMyc3Future<T>>; overload; static;
+
+        // enclose
+        class function From<T>(const Value: T): IMyc3Mutable<T>; overload; static;
+        class function From<S, T>(const Value: IMyc3Mutable<S>; const Conv: TFunc<S, IMyc3Mutable<T>>): IMyc3Mutable<T>; overload; static;
+        class function From<R, S, T>(const ValueR: IMyc3Mutable<R>; const ValueS: IMyc3Mutable<S>; const Conv: TFunc<R, S, IMyc3Mutable<T>>): IMyc3Mutable<T>; overload; static;
+
+        // Arrays
+        class function FromArray<T>(const Value: TArray<IMyc3Mutable<T>>): IMyc3Mutable<TArray<T>>; overload; static;
+        class function FromArray<S, T>(const Value: IMyc3Mutable<TArray<S>>; const Conv: TFunc<S, T>): IMyc3Mutable<TArray<T>>; overload; static;
+        class function FromArray<S, T>(const Value: IMyc3Mutable<TArray<S>>; const Conv: TFunc<S, IMyc3Mutable<T>>): IMyc3Mutable<TArray<T>>; overload; static;
+
+        class function FilterArray<T>(const Values: IMyc3Mutable<TArray<T>>; const FilterFunc: TConstFunc<T, IMyc3Mutable<Boolean>>): IMyc3Mutable<TArray<T>>; static;
+        class function SortArray<T>(const Values: IMyc3Mutable<TArray<T>>; const Comparer: IComparer<T>): IMyc3Mutable<TArray<T>>; static;
+        class function TrimArray<T: IInterface>(const Values: IMyc3Mutable<TArray<T>>): IMyc3Mutable<TArray<T>>; static;
+
+        // bool
+        class function Create( Value: Boolean ): IMyc3Mutable<Boolean>; overload; static;
+
+        class function True: IMyc3Mutable<Boolean>; overload; static; deprecated 'use TMutableBool';
+        class function False: IMyc3Mutable<Boolean>; overload; static; deprecated 'use TMutableBool';
+
+        class function OpOR(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>; static; deprecated 'use TMutableBool';
+        class function OpAND(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>; static; deprecated 'use TMutableBool';
+        class function OpNOR(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>; static; deprecated 'use TMutableBool';
+        class function OpNAND(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>; static; deprecated 'use TMutableBool';
+        class function OpNOT(const A: IMyc3Mutable<Boolean>): IMyc3Mutable<Boolean>; static; deprecated 'use TMutableBool';
+
+        class function IfThen<T>(const Condition: IMyc3Mutable<Boolean>; const TrueValue: IMyc3Mutable<T>): IMyc3Mutable<T>; overload; static;
+        class function IfThen<T>(const Condition: IMyc3Mutable<Boolean>; const TrueValue: IMyc3Mutable<IMyc3Future<T>>): IMyc3Mutable<IMyc3Future<T>>; overload; static;
+        class function IfNotThen<T>(const Condition: IMyc3Mutable<Boolean>; const FalseValue: IMyc3Mutable<T>): IMyc3Mutable<T>; static;
+        class function IfThenElse<T>(const Condition: IMyc3Mutable<Boolean>; const TrueValue, FalseValue: IMyc3Mutable<T>): IMyc3Mutable<T>; static;
+
+        class function CreateOverride<T>(const Value, Ovrride: IMyc3Mutable<TImmutable<T>>): IMyc3Mutable<TImmutable<T>>; overload; static;
+
+        class function FromSignal(const Signal: IMyc2Signal): IMyc3Mutable<Boolean>; static;
+        class function FromState(const State: IMyc2State): IMyc3Mutable<Boolean>; static;
+
+        class function CreateValidator<T>( const Comparer: IComparer<T> = nil ): IMyc3MutableCache<T>; static;
+        class function CreateCache<T>( const Comparer: IComparer<T> = nil ): TMutableCache<T>; static;
+
+        class function CreateEventObserver<T>(const Mutables: TArray<IMyc3Mutable<T>>): IMycEventObserver; static;
+        class function CreateNotifyObserver<T>(const Mutables: TArray<IMyc3Mutable<T>>): IMycNotifyObserver; static;
+
+        class function ExtractSignals<T>(const Mutables: TArray<IMyc3Mutable<T>>): IMyc2Signal; static;
+
+        class function CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>): IMyc3Mutable<TArray<T>>; overload; static;
+        class function CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>): IMyc3Mutable<IMyc3Future<TArray<T>>>; overload; static;
+
+        class function CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>; const Creator: TFunc<TArray<T>, T>): IMyc3Mutable<T>; overload; static;
+
+        class function CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>; const Creator: TFunc<TArray<T>, T>):
+            IMyc3Mutable<IMyc3Future<T>>; overload; static;
+
+        class function CreateAssembly<T, S>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>; const Creator: TFunc<TArray<T>, S>): IMyc3Mutable<S>;
+            overload; static;
+
+        class function CreateAssembly<T, S>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>; const Creator: TFunc<TArray<T>, S>):
+            IMyc3Mutable<IMyc3Future<S>>; overload; static;
+
+        class function ConvertSet<T, S>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>; const Converter: TFunc<T, S>): IMyc3Mutable<TArray<
+            IMyc3Mutable<S>>>; overload; static;
+
+        class function ConvertSet<T, S>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>; const Converter: TFunc<T, S>): IMyc3Mutable<
+            TArray< IMyc3Mutable<IMyc3Future<S>>>>; overload; static;
+
+        class function Merge<T>(const Parts: IMyc3Mutable<TArray<TArray<T>>>): IMyc3Mutable<TArray<T>>; overload; static;
+        class function Merge<T>(const Parts: IMyc3Mutable<TArray<IMyc3Future<TArray<T>>>>): IMyc3Mutable<IMyc3Future<TArray<T>>>; overload; static;
+
+        class function CreateObjectLink<T: class>(Obj: T): IMyc3ObjectLink<T>; static;
+
+        class function CreateNullable<T>: IMyc3Writeable<TImmutable<T>>; static;
+    end;
+
+    TMutableBool = record
+    private
+        FThis: IMyc3Mutable<Boolean>;
+        class function GetDefaults(Value: Boolean): IMyc3Mutable<Boolean>; static; inline;
+
+    public
+        constructor Create(const AThis: IMyc3Mutable<Boolean>);
+
+        class operator LogicalNot(const Value: TMutableBool): TMutableBool;
+        class operator LogicalAnd(const A, B: TMutableBool): TMutableBool;
+        class operator LogicalOr(const A, B: TMutableBool): TMutableBool;
+
+        class operator Equal(const A, B: TMutableBool): TMutableBool;
+        class operator NotEqual(const A, B: TMutableBool): TMutableBool;
+
+        class operator Implicit(const Value: IMyc3Mutable<Boolean>): TMutableBool; inline;
+        class operator Implicit(const Value: TMutableBool): IMyc3Mutable<Boolean>; inline;
+
+        class property Defaults[Value: Boolean]: IMyc3Mutable<Boolean> read GetDefaults;
+
+        class function True: IMyc3Mutable<Boolean>; static; inline;
+        class function False: IMyc3Mutable<Boolean>; static; inline;
+
+        property This: IMyc3Mutable<Boolean> read FThis;
+    end;
+
+    Mutable<T> = class
+    private
+        class function GetComparer: IComparer<IMyc3Mutable<T>>; static; inline;
+
+    public
+        class function Default: IMyc3Mutable<T>; static; inline;
+
+        class function IfThen( const Condition: IMyc3Mutable<Boolean>; const TrueValue: IMyc3Mutable<T> ): IMyc3Mutable<T>; static; deprecated;
+        class function IfNotThen( const Condition: IMyc3Mutable<Boolean>; const FalseValue: IMyc3Mutable<T> ): IMyc3Mutable<T>; static; deprecated;
+        class function IfThenElse( const Condition: IMyc3Mutable<Boolean>; const TrueValue, FalseValue: IMyc3Mutable<T> ): IMyc3Mutable<T>; static; deprecated;
+
+        class function CreateArray( const Arr: TArray<IMyc3Mutable<T>> ): IMyc3Mutable<TArray<T>>; overload; static;
+        class function CreateArray<S>( const Arr: IMyc3Mutable<TArray<S>>; Calculator: TFunc<S, T> ): IMyc3Mutable<TArray<T>>; overload; static;
+
+        class property Comparer: IComparer<IMyc3Mutable<T>> read GetComparer;
+    end;
+
+    TMyc2ComputeProperty<T> = record
+    private
+        FDone: IMyc2State;
+        FValue: T;
+
+    public
+        constructor Create( const StartSignal: IMyc2Signal; const Creator: TFunc<T> );
+        function Value: T; inline;
+        procedure Terminate; inline;
+        property Done: IMyc2State read FDone;
+    end;
+
+    /////////////////////////////////////////////////////////////////////////////
+    // IMyc2TaskFactory
+    //
+    IMyc2TaskFactory = interface
+        {$region 'property access'}
+        function GetThreadCount: Integer;
+        {$endregion}
+        function CreateThread( const Proc: TProc ): IMyc2State;
+        function InMainThread: Boolean;
+        function InWorkerThread: Boolean;
+        function Run( StartCount: Integer; Proc: TProc ): IMyc2Sink;
+        procedure Teardown;
+        procedure WaitFor( State: IMyc2State );
+        property ThreadCount: Integer read GetThreadCount;
+    end;
+
+    TMyc3Tasks = class( TObject )
+    private
+        FApi: IMyc2TaskFactory;
+        FEnabled: Boolean;
+        function GetInMainThread: Boolean;
+        function GetThreadCount: Integer;
+        procedure SetEnabled( const Value: Boolean );
+
+        procedure Run( const StartSignal: IMyc2Signal; const Proc: TProc ); overload;
+        procedure Run( const Proc: TProc ); overload;
+    public
+        constructor Create( const AApi: IMyc2TaskFactory );
+        destructor Destroy; override;
+        function CreateThread( const Proc: TProc ): IMyc2State;
+        procedure ExpectSignaled( State: IMyc2State; const Msg: String = 'Expected state to be already set' );
+
+        function LoopUntil( const DoneSignal: IMyc2Signal; const Proc: TFunc<IMyc2State> ): IMyc2State;
+
+        function ParallelFor(const StartSignal: IMyc2Signal; LowVal, HighVal, Slice: Integer; const Proc: TProc<Integer, Integer>): IMyc2State; overload;
+        procedure ParallelFor(LowVal, HighVal, Slice: Integer; const Proc: TProc<Integer, Integer>); overload;
+
+        function Start( const StartSignal: IMyc2Signal; const Proc: TFunc<IMyc2Signal> ): IMyc2State; overload;
+        function Start( const StartSignal: IMyc2Signal; Proc: TProc ): IMyc2State; overload;
+        function Start<T1>( const StartSignal: IMyc2Signal; P1: T1; Proc: TProc<T1> ): IMyc2State; overload;
+        function Start<T1, T2>( const StartSignal: IMyc2Signal; P1: T1; P2: T2; Proc: TProc<T1, T2> ): IMyc2State; overload;
+        function Start( const Proc: TFunc<IMyc2Signal> ): IMyc2State; overload;
+        function Start( const Proc: TProc ): IMyc2State; overload;
+
+        function Enqueue( var Queue: IMyc2State; const Proc: TFunc<IMyc2Signal> ): IMyc2State; overload;
+        function Enqueue( var Queue: IMyc2State; const Proc: TProc ): IMyc2State; overload;
+
+        function Capture<T>( P: T; Proc: TProc<T> ): TProc; overload;
+        function Capture<T, R>( P1: T; P2: R; Proc: TProc<T, R> ): TProc; overload;
+        function Capture<T, R, U>( P1: T; P2: R; P3: U; Proc: TProc<T, R, U> ): TProc; overload;
+
+        function Capture<T, R>( P: T; Proc: TFunc<T, R> ): TFunc<R>; overload;
+        function Capture<T, U, R>( P: T; Proc: TFunc<T, U, R> ): TFunc<U, R>; overload;
+        function Capture<T, U, V, R>( P: T; Proc: TFunc<T, U, V, R> ): TFunc<U, V, R>; overload;
+
+        procedure WaitFor( const State: IMyc2State );
+
+        property InMainThread: Boolean read GetInMainThread;
+        property ThreadCount: Integer read GetThreadCount;
+
+        property Enabled: Boolean write SetEnabled;
+    end;
+
+    TTag = record
+    strict private
+        FManaged: IInterface;
+        FOrdinal: Int64;
+        {$ifdef DEBUG}
+        FTypeInfo: PTypeInfo;
+        {$endif}
+
+    public
+        class function From<T>(const Data: T): TTag; static;
+        function AsType<T>: T;
+    end;
+
+    // Parameters
+
+    TParameterValue = record
+    strict private
+        FMutable: IMyc3Mutable;
+        {$ifdef DEBUG}
+        FTypeInfo: PTypeInfo;
+        procedure CheckType(TI: PTypeInfo);
+        {$endif}
+
+    public
+        constructor Create( ATypeInfo: PTypeInfo; const AMutable: IMyc3Mutable ); overload;
+        function Get<T>: T;
+        class function Create<T>( const Intf: T ): TParameterValue; overload; static;
+        class function Create<T>( const Intf: IMyc3Mutable<T> ): TParameterValue; overload; static;
+        class function Compare( const A, B: TParameterValue ): Integer; static;
+        class function FromArray<T>( const Values: TArray<TParameterValue> ): TArray<IMyc3Mutable<T>>; overload; static;
+        class function FromVarRec( const VarRec: TVarRec ): TParameterValue; static;
+        constructor Assign( const Src: TParameterValue );
+        function AsType<T>: IMyc3Mutable<T>;
+        property Mutable: IMyc3Mutable read FMutable;
+    end;
+
+    TFieldID = Integer;
+
+    TParameterField = record
+    private
+        FID: TFieldID;
+        FValue: TParameterValue;
+
+    public
+        constructor Create( AID: TFieldID; const AValue: TParameterValue ); overload;
+
+        class function Create<T>( ID: TFieldID; const Intf: T ): TParameterField; overload; static;
+        class function Create<T>( ID: TFieldID; const Intf: IMyc3Mutable<T> ): TParameterField; overload; static;
+
+        property ID: TFieldID read FID;
+        property Value: TParameterValue read FValue write FValue;
+    end;
+
+    IMycParameterRecordDefinition = interface
+        {$region 'property access'}
+        function GetByName(const Caption: String): Integer;
+        function GetCount: Integer;
+        function GetFields( Idx: Integer ): TFieldID;
+        function GetIdx: Integer;
+        {$endregion}
+        function IndexOf( Field: TFieldID ): Integer;
+        property ByName[const Caption: String]: Integer read GetByName;
+        property Count: Integer read GetCount;
+        property Fields[Idx: Integer]: TFieldID read GetFields;
+        property Idx: Integer read GetIdx;
+    end;
+
+    IMyc3ParameterRecord = interface
+        {$region 'property access'}
+        function GetByName(const Caption: String): TParameterValue;
+        function GetDef: IMycParameterRecordDefinition;
+        function GetValues(ID: TFieldID): TParameterValue;
+        {$endregion}
+        function GetEnumerator: TEnumerator<TParameterField>;
+        property ByName[const Caption: String]: TParameterValue read GetByName;
+        property Def: IMycParameterRecordDefinition read GetDef;
+        property Values[ID: TFieldID]: TParameterValue read GetValues; default;
+    end;
+
+    TParameterRecord = record
+    private
+        FThis: IMyc3ParameterRecord;
+
+        function GetValues(ID: TFieldID): TParameterValue; inline;
+        function GetByName( const Caption: String ): TParameterValue; inline;
+        function GetDef: IMycParameterRecordDefinition; inline;
+
+    public
+        constructor Create( const AThis: IMyc3ParameterRecord );
+
+        function AsType<T>( ID: TFieldID ): IMyc3Mutable<T>; inline;
+        function Get<T>(ID: TFieldID): T; inline;
+
+        class operator Implicit(const Item: IMyc3ParameterRecord): TParameterRecord;
+        class operator Implicit(const Item: TParameterRecord): IMyc3ParameterRecord;
+
+        property Def: IMycParameterRecordDefinition read GetDef;
+
+        property Values[ID: TFieldID]: TParameterValue read GetValues; default;
+        property ByName[const Caption: String]: TParameterValue read GetByName;
+    end;
+
+    IMycParameterSpace = interface
+        {$region 'property access'}
+        function GetFieldCount: Integer;
+        function GetDefaultValues( FieldID: TFieldID ): TParameterValue;
+        function GetCaptions( FieldID: TFieldID ): String;
+        function GetComparer( FieldID: TFieldID ): IComparer<TParameterValue>;
+        function GetByName(const Caption: String): TFieldID;
+        {$endregion}
+        function AddField( TypInfo: PTypeInfo; const Caption: String; const DefaultValue: IMyc3Mutable; const Comparer: IComparer<TParameterValue> ): TFieldID;
+        function CompareValues( FieldID: TFieldID; const A, B: TParameterValue ): Integer;
+        function CreateRecord(const Fields: TArray<TParameterField>): IMyc3ParameterRecord;
+        function CreateDef(const Fields: TArray<TFieldID>): IMycParameterRecordDefinition;
+        property DefaultValues[FieldID: TFieldID]: TParameterValue read GetDefaultValues;
+        property Captions[FieldID: TFieldID]: String read GetCaptions;
+        property Comparer[FieldID: TFieldID]: IComparer<TParameterValue> read GetComparer;
+        property ByName[const Caption: String]: TFieldID read GetByName;
+        property FieldCount: Integer read GetFieldCount;
+    end;
+
+    TParameterSpace = record
+    private
+        FThis: IMycParameterSpace;
+
+        function GetFieldCount: Integer; inline;
+        function GetDefaultValues( FieldID: TFieldID ): TParameterValue; inline;
+        function GetCaptions( FieldID: TFieldID ): String; inline;
+        function GetComparer( FieldID: TFieldID ): IComparer<TParameterValue>; inline;
+
+    public
+        constructor Create( const AThis: IMycParameterSpace ); overload;
+
+        class function Create: TParameterSpace; overload; static;
+
+        { TODO : ->Factory (mit D11 managed records) }
+        function AddField<T>(const Caption: String; const DefaultValue: T; const Comparer: IComparer<T> = nil): TFieldID;
+
+        function CompareValues( FieldID: TFieldID; const A, B: TParameterValue ): Integer;
+        function CreateRecord( const Fields: TArray<TParameterField> ): TParameterRecord;
+        function CreateDef(const Fields: TArray<TFieldID>): IMycParameterRecordDefinition;
+
+        class operator Implicit( const Item: TParameterSpace ): IMycParameterSpace;
+        class operator Implicit( const Item: IMycParameterSpace ): TParameterSpace;
+
+        property FieldCount: Integer read GetFieldCount;
+        property DefaultValues[FieldID: TFieldID]: TParameterValue read GetDefaultValues;
+        property Captions[FieldID: TFieldID]: String read GetCaptions;
+        property Comparer[FieldID: TFieldID]: IComparer<TParameterValue> read GetComparer;
+    end;
+
+type
+    TStackTrace = record
+    const
+        Len = 64;
+    var
+        Msg: String;
+        StackTrace: array [0..Len-1] of NativeUInt;
+        constructor Create(ASkipFrames: Cardinal; const AMsg: String = '');
+        function ToText: String;
+    end;
+
+var
+    Tasks: TMyc3Tasks;
+
+procedure RaiseInvalidParameter( const Msg: String = '' );
+procedure RaiseNullPointer;
+procedure RaiseInvalidOperation( const Msg: String = '' ); overload;
+procedure RaiseInvalidOperation( const Msg: String; const Args: array of const ); overload;
+
+procedure ForEach( Count: Integer; Exec: TProc<Integer> ); overload;
+procedure ForEach( Count1, Count2: Integer; Exec: TProc<Integer, Integer> ); overload;
+procedure ForEach( Count1, Count2, Count3: Integer; Exec: TProc<Integer, Integer, Integer> ); overload;
+procedure ForEach( LowIdx, HighIdx: Integer; Exec: TProc<Integer> ); overload;
+
+implementation
+
+uses
+    System.Classes, System.SyncObjs, System.SysConst, System.Math,
+    Myc.Signals, Myc.Tasks, Myc.Values, Myc.Values.Sets, Myc.Values.Validate,
+    Myc.Values.Properties, Myc.Values.Bool, Myc.Atomic, Myc.Future.Arrays,
+    Myc.Values.Parameter;
+
+procedure RaiseInvalidParameter( const Msg: String = '' );
+var
+    Str: String;
+begin
+    Str := 'Invalid parameter';
+    if Msg <> '' then
+        Str := Str + ' (' + Msg + ')';
+
+    raise EMycInvalidParameter.Create( Str );
+end;
+
+procedure RaiseNullPointer;
+begin
+    RaiseInvalidParameter( 'null pointer' );
+end;
+
+procedure RaiseInvalidOperation( const Msg: String ); overload;
+begin
+    RaiseInvalidOperation( Msg, [] );
+end;
+
+procedure RaiseInvalidOperation( const Msg: String; const Args: array of const ); overload;
+begin
+    if Msg = '' then
+        raise EMycInvalidOperation.Create( 'Invalid operation' )
+    else
+        raise EMycInvalidOperation.CreateFmt( 'Invalid operation: ' + Msg, Args )
+end;
+
+procedure ForEach( Count: Integer; Exec: TProc<Integer> );
+var
+    i: Integer;
+begin
+    for i := 0 to Count - 1 do
+        Exec( i );
+end;
+
+procedure ForEach( Count1, Count2: Integer; Exec: TProc<Integer, Integer> );
+var
+    i, j: Integer;
+begin
+    for i := 0 to Count1 - 1 do
+        for j := 0 to Count2 - 1 do
+            Exec( i, j );
+end;
+
+procedure ForEach( Count1, Count2, Count3: Integer; Exec: TProc<Integer, Integer, Integer> );
+var
+    i, j, k: Integer;
+begin
+    for i := 0 to Count1 - 1 do
+        for j := 0 to Count2 - 1 do
+            for k := 0 to Count3 - 1 do
+                Exec( i, j, k );
+end;
+
+procedure ForEach( LowIdx, HighIdx: Integer; Exec: TProc<Integer> ); overload;
+var
+    i: Integer;
+begin
+    for i := LowIdx to HighIdx do
+        Exec( i );
+end;
+
+{ TMyc3Tasks }
+
+constructor TMyc3Tasks.Create( const AApi: IMyc2TaskFactory );
+begin
+    inherited Create;
+    FApi := AApi;
+    FEnabled := True;
+end;
+
+destructor TMyc3Tasks.Destroy;
+begin
+    FApi.Teardown;
+    inherited;
+end;
+
+function TMyc3Tasks.Capture<T, R, U>( P1: T; P2: R; P3: U; Proc: TProc<T, R, U> ): TProc;
+begin
+    Result :=
+        procedure
+        begin
+            Proc( P1, P2, P3 );
+        end;
+end;
+
+function TMyc3Tasks.Capture<T, R>( P: T; Proc: TFunc<T, R> ): TFunc<R>;
+begin
+    Result :=
+        function: R
+        begin
+            Result := Proc( P );
+        end;
+end;
+
+function TMyc3Tasks.Capture<T, R>( P1: T; P2: R; Proc: TProc<T, R> ): TProc;
+begin
+    Result :=
+        procedure
+        begin
+            Proc( P1, P2 );
+        end;
+end;
+
+function TMyc3Tasks.Capture<T, U, R>( P: T; Proc: TFunc<T, U, R> ): TFunc<U, R>;
+begin
+    Result :=
+        function( Q: U ): R
+        begin
+            Result := Proc( P, Q );
+        end;
+end;
+
+function TMyc3Tasks.Capture<T, U, V, R>( P: T; Proc: TFunc<T, U, V, R> ): TFunc<U, V, R>;
+begin
+    Result :=
+        function( Q: U; R: V ): R
+        begin
+            Result := Proc( P, Q, R );
+        end;
+end;
+
+function TMyc3Tasks.Capture<T>( P: T; Proc: TProc<T> ): TProc;
+begin
+    Result :=
+        procedure
+        begin
+            Proc( P );
+        end;
+end;
+
+function TMyc3Tasks.CreateThread( const Proc: TProc ): IMyc2State;
+begin
+    Result := FApi.CreateThread( Proc );
+end;
+
+{ TSet<T> }
+
+class function TSet<T>.Create: IMycSet<T>;
+begin
+    Result := TMycSet<T>.Create;
+end;
+
+class function TSet<T>.CreateEx( const Arr: TArray<T> ): IMycEnumArray<T>;
+begin
+    Result := TMycEnumArray<T>.CreateStatic( Arr );
+end;
+
+class function TSet<T>.Create( const Arr: IMyc3Mutable<TArray<T>> ): IMycEnumArray<T>;
+begin
+    Result := TMycEnumArray<T>.CreateMutable( Arr );
+end;
+
+{ TFuture }
+
+class function TFuture.From<S, T>(const Value: IMyc3Future<S>; const Conv: TFunc<S, T>): IMyc3Future<T>;
+begin
+    Result := TMyc3Future<T>.CreateFuture( Value.Initialized,
+        function: T
+        begin
+            Result := Conv( Value.Value );
+        end );
+end;
+
+class function TFuture.Combine<S, T>(const Value: TArray<IMyc3Future<S>>;
+  const Calculator: TFunc<TArray<S>, T>): IMyc3Future<T>;
+begin
+    Result := TValue<T>.CreateFuture<S>( Value, Calculator );
+end;
+
+class function TFuture.From<S, T>(const Value: IMyc3Future<S>; const Conv: TFunc<S, IMyc3Future<T>>): IMyc3Future<T>;
+begin
+    Result := TMyc3Future<T>.CreateFuture( Value.Initialized,
+        function: IMyc3Future<T>
+        begin
+            Result := Conv( Value.Value );
+        end );
+end;
+
+class function TFuture.FromArray<T>(const Value: TArray<IMyc3Future<T>>): IMyc3Future<TArray<T>>;
+begin
+    Result := TMyc3FutureArrayEx<T>.Create( Value );
+end;
+
+class function TFuture.Merge<T>(const Parts: TArray<TArray<T>>): TArray<T>;
+var
+    i, j, n: Integer;
+begin
+    n := 0;
+    for i := 0 to High(Parts) do
+        inc( n, Length(Parts[i]) );
+
+    SetLength( Result, n );
+    n := 0;
+    for i := 0 to High(Parts) do
+    begin
+        for j := 0 to High(Parts[i]) do
+        begin
+            Result[n] := Parts[i,j];
+            inc(n);
+        end;
+    end;
+end;
+
+class function TFuture.Merge<T>(const Parts: TArray<IMyc3Future<TArray<T>>>): IMyc3Future<TArray<T>>;
+begin
+    if Length(Parts) = 0 then
+        Result := TValue<TArray<T>>.DefaultFuture
+    else if Length(Parts) = 1 then
+        Result := Parts[0]
+    else
+        Result := TValue<TArray<T>>.CreateFuture<TArray<TArray<T>>>(
+            TValue<TArray<T>>.CreateFuture( Parts ),
+            function( Parts: TArray<TArray<T>> ): TArray<T>
+            begin
+                Result := Merge<T>( Parts );
+            end );
+end;
+
+{ TMutableFuture<T> }
+
+class constructor TMutableFuture<T>.CreateClass;
+begin
+    FNull := TValue<IMyc3Future<T>>.CreateMutable( TValue<T>.DefaultFuture );
+end;
+
+class function TMutableFuture<T>.Create<S>( const P: IMyc3Mutable<IMyc3Future<T>>; Calc: TFunc<T, S> ): IMyc3Mutable<IMyc3Future<S>>;
+begin
+    Result := TValue<IMyc3Future<S>>.CreateMutable<IMyc3Future<T>>(
+        P,
+            function( P: IMyc3Future<T> ): IMyc3Future<S>
+        begin
+            Result := TValue<S>.CreateFuture<T>(
+                P,
+                    function( P: T ): S
+                begin
+                    Result := Calc( P );
+                end );
+        end );
+end;
+
+class function TMutableFuture<T>.GetNull: IMyc3Mutable<IMyc3Future<T>>;
+begin
+    Result := FNull;
+end;
+
+{ TImmutable<T> }
+
+constructor TImmutable<T>.Create(const AValue: T);
+begin
+    FThis := TMyc3Value<T>.Create( AValue );
+end;
+
+function TImmutable<T>.GetValue: T;
+begin
+    if FThis<>nil then
+        Result := FThis.Value
+    else
+        Result := Default(T);
+end;
+
+function TImmutable<T>.GetHasValue: Boolean;
+begin
+    Result := FThis<>nil;
+end;
+
+class function TImmutable<T>.GetNull: TImmutable<T>;
+begin
+    Result := Default(TImmutable<T>);
+end;
+
+class operator TImmutable<T>.Equal(ALeft, ARight: TImmutable<T>): Boolean;
+begin
+    if ALeft.HasValue and ARight.HasValue then
+        Result := TEqualityComparer<T>.Default.Equals(ALeft.Value, ARight.Value)
+    else
+        Result := ALeft.HasValue = ARight.HasValue;
+end;
+
+class operator TImmutable<T>.NotEqual(ALeft, ARight: TImmutable<T>): Boolean;
+begin
+    if ALeft.HasValue and ARight.HasValue then
+        Result := not TEqualityComparer<T>.Default.Equals(ALeft.Value, ARight.Value)
+    else
+        Result := ALeft.HasValue <> ARight.HasValue;
+end;
+
+{ TMyc3Tasks }
+
+function TMyc3Tasks.Enqueue( var Queue: IMyc2State; const Proc: TFunc<IMyc2Signal> ): IMyc2State;
+var
+    Exec: IMyc2Condition;
+    [unsafe]
+    Q: IMyc2State;
+begin
+    Exec := Signals.CreateCounter( 1 );
+
+    Result := Exec.State;
+
+    Result._AddRef;
+    Pointer( Q ) := TInterlocked.Exchange( Pointer( Queue ), Pointer( Result ) );
+    try
+        Start( Q, Proc ).Advise( Exec );
+    finally
+        Q._Release;
+    end;
+end;
+
+function TMyc3Tasks.Enqueue( var Queue: IMyc2State; const Proc: TProc ): IMyc2State;
+var
+    Exec: IMyc2Condition;
+    [unsafe]
+    Q: IMyc2State;
+begin
+    Exec := Signals.CreateCounter( 1 );
+
+    Result := Exec.State;
+
+    Result._AddRef;
+    Pointer( Q ) := TInterlocked.Exchange( Pointer( Queue ), Pointer( Result ) );
+    try
+        Start( Q, Proc ).Advise( Exec );
+    finally
+        Q._Release;
+    end;
+end;
+
+procedure TMyc3Tasks.ExpectSignaled( State: IMyc2State; const Msg: String = 'Expected state to be already set' );
+begin
+    System.Assert( Signals.IsStatic( State ) or State.IsSet, Msg );
+end;
+
+function TMyc3Tasks.GetInMainThread: Boolean;
+begin
+    Result := FApi.InMainThread;
+end;
+
+function TMyc3Tasks.GetThreadCount: Integer;
+begin
+    Result := FApi.ThreadCount;
+end;
+
+function TMyc3Tasks.LoopUntil( const DoneSignal: IMyc2Signal; const Proc: TFunc<IMyc2State> ): IMyc2State;
+var
+    Done: IMyc2Event;
+    CapturedProc: TFunc<IMyc2State>;
+begin
+    if Signals.IsStatic( DoneSignal ) then
+        exit( Signals.Null.State );
+
+    DoneSignal._AddRef;
+    try
+        Done := Signals.CreateEvent( false );
+        DoneSignal.Advise( Done );
+
+        CapturedProc := Proc;
+
+        Result := FApi.CreateThread(
+            procedure
+            begin
+                try
+                    while not Done.State.IsSet do
+                        WaitFor( CapturedProc );
+                finally
+                    CapturedProc := nil;
+                end;
+            end );
+    finally
+        DoneSignal._Release;
+    end;
+end;
+
+function TMyc3Tasks.ParallelFor(const StartSignal: IMyc2Signal; LowVal, HighVal, Slice: Integer; const Proc: TProc<Integer, Integer>):
+    IMyc2State;
+
+    function CallFunc( f, l: Integer; Proc: TProc<Integer, Integer> ): IMyc2State;
+    begin
+        Result := Start(
+            StartSignal,
+            procedure
+            begin
+                Proc( f, l );
+            end );
+    end;
+
+var
+    l, f, n: Integer;
+    Counter: IMyc2Condition;
+begin
+    if not Assigned( Proc ) or ( LowVal > HighVal ) then
+        exit;
+
+    if Slice <= 0 then
+        Slice := max( 1, (HighVal-LowVal+1) div ThreadCount );
+
+    n := 0;
+    f := LowVal;
+    while f <= HighVal do
+    begin
+        inc( f, Slice );
+        inc( n );
+    end;
+
+    if n=0 then
+        exit;
+
+    Counter := Signals.CreateCounter( n );
+
+    f := LowVal;
+    while f <= HighVal do
+    begin
+        l := f + Slice - 1;
+        if l > HighVal then
+            l := HighVal;
+
+        CallFunc( f, l, Proc ).Advise( Counter );
+
+        f := l + 1;
+    end;
+
+    Result := Counter.State;
+end;
+
+procedure TMyc3Tasks.ParallelFor(LowVal, HighVal, Slice: Integer; const Proc: TProc<Integer, Integer>);
+begin
+    if Slice <= 0 then
+        Slice := max( 1, (HighVal-LowVal+1) div ThreadCount );
+
+    if HighVal - LowVal >= Slice then
+        WaitFor( ParallelFor( nil, LowVal, HighVal, Slice, Proc ) )
+    else
+        Proc( LowVal, HighVal );
+end;
+
+procedure TMyc3Tasks.Run( const StartSignal: IMyc2Signal; const Proc: TProc );
+begin
+    if not Signals.IsStatic( StartSignal ) then
+    begin
+        if FEnabled then
+            StartSignal.Advise( FApi.Run( 1, Proc ) )
+        else
+            StartSignal.Advise( Signals.CreateSink( True, Proc ) );
+    end
+    else
+        Run( Proc );
+end;
+
+procedure TMyc3Tasks.Run( const Proc: TProc );
+begin
+    if FEnabled then
+        FApi.Run( 0, Proc )
+    else
+        Proc( );
+end;
+
+procedure TMyc3Tasks.SetEnabled( const Value: Boolean );
+begin
+    {$ifndef DisableThreading}
+    FEnabled := Value;
+    {$endif}
+end;
+
+function TMyc3Tasks.Start( const StartSignal: IMyc2Signal; const Proc: TFunc<IMyc2Signal> ): IMyc2State;
+var
+    Done: IMyc2Condition;
+    CapturedProc: TFunc<IMyc2Signal>;
+begin
+    if not Assigned( Proc ) then
+        exit( Signals.Null.State );
+
+    Done := Signals.CreateCounter( 1 );
+
+    CapturedProc := Proc;
+
+    Run( StartSignal,
+        procedure
+        var
+            Sig: IMyc2Signal;
+        begin
+            try
+                Sig := CapturedProc( );
+            finally
+                CapturedProc := nil;
+
+                if not Signals.IsStatic( Sig ) then
+                    Sig.Advise( Done )
+                else
+                    Done.Notify;
+            end;
+        end );
+
+    exit( Done.State );
+end;
+
+function TMyc3Tasks.Start( const StartSignal: IMyc2Signal; Proc: TProc ): IMyc2State;
+var
+    Done: IMyc2Condition;
+begin
+    Assert( Assigned( Proc ) );
+    Done := Signals.CreateCounter( 1 );
+
+    Run( StartSignal,
+        procedure
+        begin
+            try
+                Proc;
+            finally
+                Done.Notify;
+            end;
+        end );
+
+    exit( Done.State );
+end;
+
+function TMyc3Tasks.Start( const Proc: TFunc<IMyc2Signal> ): IMyc2State;
+begin
+    Result := Start( nil, Proc );
+end;
+
+function TMyc3Tasks.Start( const Proc: TProc ): IMyc2State;
+begin
+    Result := Start( nil, Proc );
+end;
+
+function TMyc3Tasks.Start<T1, T2>( const StartSignal: IMyc2Signal; P1: T1; P2: T2; Proc: TProc<T1, T2> ): IMyc2State;
+begin
+    Result := Start( StartSignal,
+        procedure
+        begin
+            Proc( P1, P2 );
+        end );
+end;
+
+function TMyc3Tasks.Start<T1>( const StartSignal: IMyc2Signal; P1: T1; Proc: TProc<T1> ): IMyc2State;
+begin
+    Result := Start( StartSignal,
+        procedure
+        begin
+            Proc( P1 );
+        end );
+end;
+
+procedure TMyc3Tasks.WaitFor( const State: IMyc2State );
+begin
+    FApi.WaitFor( State );
+end;
+
+{ TValue<T> }
+
+class constructor TValue<T>.CreateClass;
+begin
+    FDefaultMutable := TMyc3ConstantMutable<T>.Create( Default(T) );
+    FDefaultMutableFuture := TMyc3ConstantMutable<IMyc3Future<T>>.Create( TMyc3ConstantFuture<T>.Create( Default(T) ) );
+end;
+
+class function TValue<T>.Capture( const Src: TArray<T> ): TArray<T>;
+var
+    i: Integer;
+begin
+    SetLength( Result, Length( Src ) );
+    for i := 0 to High( Src ) do
+        Result[i] := Src[i];
+end;
+
+class function TValue<T>.CreateFuture( Future: IMyc3Future<T>; Creator: TFunc < T, IMyc3Future < T >> ): IMyc3Future<T>;
+begin
+    Result := TMyc3Future<T>.CreateFuture( Future.Initialized,
+        function: IMyc3Future<T>
+        begin
+            Result := Creator( Future.Value );
+        end );
+end;
+
+class function TValue<T>.CreateFuture( const StartSignal: IMyc2Signal; const Calculator: TFunc < IMyc3Future < T >> )
+: IMyc3Future<T>;
+begin
+    Result := TMyc3Future<T>.CreateFuture( StartSignal,
+        function: IMyc3Future<T>
+        begin
+            Result := Calculator( );
+        end );
+end;
+
+class function TValue<T>.Combine<V>( const Values: TArray<IMyc3Future<V>>; Combiner: TMyc3Combiner<T, V> ): IMyc3Future<T>;
+begin
+    if Values=nil then
+        exit( DefaultFuture );
+
+    Result := CreateFuture<V>( Values,
+        function( Arr: TArray<V> ): T
+        begin
+            Result := Combiner( Arr );
+        end );
+end;
+
+class function TValue<T>.Combine<V>( Values: TArray<V>; Combiner: TMyc3Combiner<T, V> ): IMyc3Future<T>;
+begin
+    if Values=nil then
+        exit( DefaultFuture );
+
+    Result := TValue<T>.CreateFuture(
+        function: T
+        begin
+            Result := Combiner( Values );
+        end );
+end;
+
+class function TValue<T>.Combine<V>(const Values: TArray<IMyc3Mutable<V>>; Combiner: TMyc3Combiner<T, V>): IMyc3Mutable<T>;
+var
+    Chg: TArray<IMyc2Signal>;
+    i: Integer;
+begin
+    Result := Mutable.Convert<TArray<V>, T>(
+        TValue<V>.CreateMutable(Values),
+        function( Values: TArray<V> ): T
+        begin
+            if not Assigned( Combiner ) then
+                exit( Default( T ) );
+            Result := Combiner( Values );
+        end );
+end;
+
+class function TValue<T>.CreateAnimator( const Target: IMyc3Mutable<T>; const Interpolator: TMyc3TargetInterpolator<T> )
+: IMyc3Animator<T>;
+begin
+    Result := CreateAnimator( Target.Value, Target.Changed,
+        function( Delta: Double; const StartValue: T; out Value: T ): Boolean
+        begin
+            Result := Interpolator( Delta, StartValue, Target.Value, Value );
+            if not Result then
+                Value := Target.Value;
+        end );
+end;
+
+class function TValue<T>.CreateAnimator( const Init: T; const ChangeSignal: IMyc2Signal;
+const Interpolator: TMyc3Interpolator<T> ): IMyc3Animator<T>;
+begin
+    Result := TMyc3Animator<T>.Create( Init, ChangeSignal, Interpolator );
+end;
+
+class function TValue<T>.AsFuture( const Value: T ): IMyc3Future<T>;
+begin
+    Result := TMyc3ConstantFuture<T>.Create( Value );
+end;
+
+class function TValue<T>.CreateFuture( const StartSignal: IMyc2Signal; const Calculator: TFunc<T> ): IMyc3Future<T>;
+begin
+    Result := TMyc3Future<T>.CreateFuture( StartSignal, Calculator );
+end;
+
+class function TValue<T>.CreateFuture( const Calculator: TFunc<T> ): IMyc3Future<T>;
+begin
+    Result := TMyc3Future<T>.CreateFuture( Calculator );
+end;
+
+class function TValue<T>.CreateFuture<S>( const Params: TArray<IMyc3Future<S>>; Calculator: TFunc<TArray<S>, T> ): IMyc3Future<T>;
+var
+    Counter: IMyc2Condition;
+    i: Integer;
+    Arr: TArray<IMyc3Future<S>>;
+begin
+    Counter := Signals.CreateCounter( Length( Params ) );
+    SetLength( Arr, Length( Params ) );
+
+    for i := 0 to High( Params ) do
+    begin
+        if Params[i]<>nil then
+        begin
+            Arr[i] := Params[i];
+            Arr[i].Initialized.Advise( Counter );
+        end
+        else
+            Counter.Notify;
+    end;
+
+    Result := TMyc3Future<T>.CreateFuture( Counter.State,
+        function: T
+        var
+            Values: TArray<S>;
+            i: Integer;
+        begin
+            SetLength( Values, Length( Arr ) );
+            for i := 0 to High( Values ) do
+                if Arr[i]<>nil then
+                    Values[i] := Arr[i].Value;
+
+            Result := Calculator( Values );
+        end );
+end;
+
+class function TValue<T>.CreateFuture<U, V>( P1: IMyc3Future<U>; P2: IMyc3Future<V>; Calculator: TFunc<U, V, T> ): IMyc3Future<T>;
+var
+    Counter: IMyc2Condition;
+begin
+    Assert( Assigned( P1 ) and Assigned( P2 ) );
+    Counter := Signals.CreateCounter( 2 );
+
+    P1.Initialized.Advise( Counter );
+    P2.Initialized.Advise( Counter );
+
+    Result := CreateFuture( Counter.State,
+        function: T
+        begin
+            Result := Calculator( P1.Value, P2.Value );
+        end );
+end;
+
+class function TValue<T>.CreateFuture<U, V>( P1: IMyc3Future<U>; P2: IMyc3Future<V>; Calculator: TFunc < U, V, IMyc3Future < T >>
+    ): IMyc3Future<T>;
+var
+    Counter: IMyc2Condition;
+begin
+    Assert( Assigned( P1 ) and Assigned( P2 ) );
+    Counter := Signals.CreateCounter( 2 );
+
+    P1.Initialized.Advise( Counter );
+    P2.Initialized.Advise( Counter );
+
+    Result := CreateFuture( Counter.State,
+        function: IMyc3Future<T>
+        begin
+            Result := Calculator( P1.Value, P2.Value );
+        end );
+end;
+
+class function TValue<T>.CreateFuture<U>( P: IMyc3Future<U>; Calculator: TFunc<U, T> ): IMyc3Future<T>;
+begin
+    Assert( Assigned( P ) );
+    Result := CreateFuture( P.Initialized,
+        function: T
+        begin
+            Result := Calculator( P.Value );
+        end );
+end;
+
+class function TValue<T>.CreateFuture<U>( P: IMyc3Future<U>; Calculator: TFunc < U, IMyc3Future < T >> ): IMyc3Future<T>;
+begin
+    Assert( Assigned( P ) );
+    Result := CreateFuture( P.Initialized,
+        function: IMyc3Future<T>
+        begin
+            Result := Calculator( P.Value );
+        end );
+end;
+
+class function TValue<T>.AsImmutable( const Value: T ): IMyc3Value<T>;
+begin
+    Result := TMyc3Value<T>.Create( Value );
+end;
+
+class function TValue<T>.CreateLazy(const Func: TFunc<T>): IMyc3Value<T>;
+begin
+    Result := TMyc3Lazy<T>.Create( Func );
+end;
+
+class function TValue<T>.CreateFuture( const Values: TArray < IMyc3Future < T >> ): IMyc3Future<TArray<T>>;
+begin
+    Result := TMyc3FutureArrayEx<T>.Create( Values );
+end;
+
+class function TValue<T>.CreateFuture<S>( const Values: TArray<IMyc3Future<S>>; const Calculator: TFunc<Integer, S, T> ):
+    IMyc3Future<TArray<T>>;
+begin
+    Result := TMyc3FutureArrayConvert<T, S>.Create( Values, Calculator );
+end;
+
+class function TValue<T>.CreateFuture<U, V, W>( P1: IMyc3Future<U>; P2: IMyc3Future<V>; P3: IMyc3Future<W>;
+Calculator: TFunc<U, V, W, T> ): IMyc3Future<T>;
+var
+    Counter: IMyc2Condition;
+begin
+    Assert( Assigned( P1 ) and Assigned( P2 ) and Assigned( P3 ) );
+    Counter := Signals.CreateCounter( 3 );
+
+    P1.Initialized.Advise( Counter );
+    P2.Initialized.Advise( Counter );
+    P3.Initialized.Advise( Counter );
+
+    Result := CreateFuture( Counter.State,
+        function: T
+        begin
+            Result := Calculator( P1.Value, P2.Value, P3.Value );
+        end );
+end;
+
+class function TValue<T>.CreateFutures( Count: Integer; const Src: IMyc3Future < TArray < T >> ): TArray<IMyc3Future<T>>;
+begin
+    Result := TMyc3FutureArray<T>.CreateFutures( Count, Src );
+end;
+
+class function TValue<T>.CreateMutable( const Value: T ): IMyc3Mutable<T>;
+begin
+    Result := AsConst( Value );
+end;
+
+class function TValue<T>.CreateMutable( const Changed: array of IMyc2Signal; const Calculator: TFunc<T> ): IMyc3Mutable<T>;
+begin
+    Result := TMyc3Mutable<T>.CreateMutable( Changed, Calculator );
+end;
+
+class function TValue<T>.AsMutable( const Value: IMyc3Mutable<IMyc3Mutable<T>> ): IMyc3Mutable<T>;
+begin
+    Result := TMyc3EnclosedMutable<T>.Create( Value );
+end;
+
+class function TValue<T>.AsMutable( const Value: IMyc3Mutable<IMyc3Value<T>> ): IMyc3Mutable<T>;
+begin
+    Result := TValue<T>.CreateMutable<IMyc3Value<T>>(
+    Value,
+        function( Immutable: IMyc3Value<T> ): T
+        begin
+            if Immutable<>nil then
+                Result := Immutable.Value
+            else
+                Result := default ( T );
+        end );
+end;
+
+class function TValue<T>.AsConst( const Value: T ): IMyc3Mutable<T>;
+begin
+    Result := TMyc3ConstantMutable<T>.Create( Value );
+end;
+
+class function TValue<T>.AsMutable(const Value: IMyc3Future<T>): IMyc3Mutable<T>;
+begin
+    Result := TMyc3FutureAsMutable<T>.CreateFutureAsMutable( Value )
+end;
+
+class function TValue<T>.AsMutable(const Value: IMyc3Mutable<IMyc3Future<T>>): IMyc3Mutable<T>;
+begin
+    Result := TMyc3EnclosedMutable<T>.Create(
+        TMyc3Mutable<IMyc3Mutable<T>>.CreateMutable(
+            Value.Changed,
+            function: IMyc3Mutable<T>
+            begin
+                Result := AsMutable( Value.Value );
+            end ) );
+end;
+
+class function TValue<T>.Convert<S>( P: IMyc3Future<S>; const Converter: TFunc<S, T> ): IMyc3Future<T>;
+begin
+    if P.Initialized.IsSet then
+        Result := AsFuture( Converter( P.Value ) )
+    else
+        Result := CreateFuture<S>( P, Converter );
+end;
+
+class function TValue<T>.CreateGeneric(const Calculator: TFunc<T>): IMyc3Generic<T>;
+begin
+    Result := TMyc3Changeable<T>.CreateGeneric( Calculator );
+end;
+
+class function TValue<T>.CreateFutureArray( const StartSignal: IMyc2Signal; Count: Integer; const Calculator: TFunc<Integer, T> ):
+    IMyc3Future<TArray<T>>;
+var
+    Init: IMyc2State;
+    Arr: TArray<T>;
+    Calc: TFunc<Integer, T>;
+begin
+    SetLength( Arr, Count );
+
+    Calc := Calculator;
+    Init := Tasks.ParallelFor(
+        StartSignal,
+        0, Count-1, 1,
+        procedure( A, B: Integer )
+        var
+            i: Integer;
+        begin
+            for i := A to B do
+                Calc( i )
+        end );
+
+    Result := TMyc3Future<TArray<T>>.CreateFuture( Init, Arr );
+end;
+
+class function TValue<T>.CreateFutureArray( Count: Integer; const Calculator: TFunc<Integer, T> ): IMyc3Future<TArray<T>>;
+begin
+    Result := CreateFutureArray( Signals.Null.State, Count, Calculator );
+end;
+
+class function TValue<T>.CreateValidate( const Calculator: TFunc<T> ): IMyc3ValidateMutable<T>;
+begin
+    Result := TMyc3ValidateMutable<T>.Create( Calculator );
+end;
+
+class function TValue<T>.CreateMutable( const Arr: TArray < IMyc3Mutable < T >> ): IMyc3Mutable<TArray<T>>;
+begin
+    Result := TMyc3Mutable<T>.CreateArray( Arr );
+end;
+
+class function TValue<T>.CreateMutable( Calculator: TFunc<T> ): IMyc3Mutable<T>;
+begin
+    Result := CreateMutable( [], Calculator );
+end;
+
+class function TValue<T>.CreateMutable( const Event: IMycEventObserver; const Calculator: TFunc<T> ): IMyc3Mutable<T>;
+begin
+    Result := TMyc3Mutable<T>.CreateMutable( Event, Calculator );
+end;
+
+class function TValue<T>.CreateMutable( const Changed: array of IMyc2Signal; const Mutable: IMyc3Mutable<T> ): IMyc3Mutable<T>;
+var
+    Notifier: IMyc2Notifier;
+    i: Integer;
+begin
+    Notifier := Signals.CreateNotifier;
+    Mutable.Changed.Advise( Notifier );
+    for i := 0 to High( Changed ) do
+        Changed[i].Advise( Notifier );
+
+    Result := TMyc3Mutable<T>.CreateMutable(
+    Notifier.Signal,
+        function: T
+        begin
+            Result := Mutable.Value;
+        end );
+end;
+
+class function TValue<T>.CreateMutable(const Changed: array of IMyc2Signal; const Calculator: TFunc<IMyc3Mutable<T>>): IMyc3Mutable<T>;
+begin
+    Result := TMyc3EnclosedMutable<T>.Create( TMyc3Mutable<IMyc3Mutable<T>>.CreateMutable( Changed, Calculator ) );
+end;
+
+class function TValue<T>.CreateMutable<U, V, W>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>;
+Calculator: TFunc<U, V, W, T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( P1 ) and Assigned( P2 ) and Assigned( P3 ) );
+
+    if not Signals.IsStatic(P1.Changed) or not Signals.IsStatic(P2.Changed) or not Signals.IsStatic(P3.Changed) then
+    begin
+        Result := TMyc3Mutable<T>.CreateMutable(
+        [P1.Changed, P2.Changed, P3.Changed],
+            function: T
+            begin
+                Result := Calculator( P1.Value, P2.Value, P3.Value );
+            end );
+    end
+    else
+        Result := TMyc3ConstantMutable<T>.Create( Calculator( P1.Value, P2.Value, P3.Value ) );
+end;
+
+class function TValue<T>.CreateMutable<U, V, W, X>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>;
+P4: IMyc3Mutable<X>; Calculator: TFunc<U, V, W, X, T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( P1 ) and Assigned( P2 ) and Assigned( P3 ) and Assigned( P4 ) );
+
+    if not Signals.IsStatic(P1.Changed) or not Signals.IsStatic(P2.Changed) or not Signals.IsStatic(P3.Changed) or not Signals.IsStatic(P4.Changed) then
+    begin
+        Result := TMyc3Mutable<T>.CreateMutable(
+        [P1.Changed, P2.Changed, P3.Changed, P4.Changed],
+            function: T
+            begin
+                Result := Calculator( P1.Value, P2.Value, P3.Value, P4.Value );
+            end );
+    end
+    else
+        Result := TMyc3ConstantMutable<T>.Create( Calculator( P1.Value, P2.Value, P3.Value, P4.Value ) );
+end;
+
+class function TValue<T>.CreateMutableEx<S>( Params: TArray<IMyc3Mutable<S>>; Calculator: TFunc<TArray<S>, T> ): IMyc3Mutable<T>;
+var
+    i: Integer;
+    Sigs: TArray<IMyc2Signal>;
+begin
+    case Length( Params ) of
+    0:
+        Result := CreateMutable(
+            function: T
+            begin
+                Result := Calculator( [] );
+            end );
+    1:
+        Result := CreateMutable<S>( Params[0],
+            function( P: S ): T
+            begin
+                Result := Calculator( [P] );
+            end );
+    2:
+        Result := CreateMutable<S, S>( Params[0], Params[1],
+            function( P1, P2: S ): T
+            begin
+                Result := Calculator( [P1, P2] );
+            end );
+    3:
+        Result := CreateMutable<S, S, S>( Params[0], Params[1], Params[2],
+            function( P1, P2, P3: S ): T
+            begin
+                Result := Calculator( [P1, P2, P3] );
+            end );
+    4:
+        Result := CreateMutable<S, S, S, S>( Params[0], Params[1], Params[2], Params[3],
+            function( P1, P2, P3, P4: S ): T
+            begin
+                Result := Calculator( [P1, P2, P3, P4] );
+            end );
+    else
+        begin
+            SetLength( Sigs, Length( Params ) );
+
+            for i := 0 to High( Sigs ) do
+            begin
+                Assert( Assigned( Params[i] ) );
+                Sigs[i] := Params[i].Changed;
+            end;
+
+            Result := TMyc3Mutable<T>.CreateMutable(
+            Sigs,
+                function: T
+                var
+                    Values: TArray<S>;
+                    Init: IMyc2Signal;
+                    i: Integer;
+                begin
+                    SetLength( Values, Length( Params ) );
+                    for i := 0 to High( Values ) do
+                        Values[i] := Params[i].Value;
+
+                    Result := Calculator( Values );
+                end );
+        end;
+    end;
+end;
+
+class function TValue<T>.CreateMutable<S>( const Arr: TArray<IMyc3Mutable<S>>; Calculator: TFunc<Integer, S, T> ):
+    IMyc3Mutable<TArray<T>>;
+begin
+    Result := TMyc3MutableArray<T, S>.Create( Arr, Calculator );
+end;
+
+class function TValue<T>.CreateMutable<U, V, W, X, Y, Z>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>; P4:
+    IMyc3Mutable<X>; P5: IMyc3Mutable<Y>; P6: IMyc3Mutable<Z>; Calculator: TFunc<U, V, W, X, Y, Z, T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( P1 ) and Assigned( P2 ) and Assigned( P3 ) and Assigned( P4 ) and Assigned( P5 ) and Assigned( P6 ) );
+
+    if not Signals.IsStatic(P1.Changed) or not Signals.IsStatic(P2.Changed) or not Signals.IsStatic(P3.Changed)
+        or not Signals.IsStatic(P4.Changed) or not Signals.IsStatic(P5.Changed) or not Signals.IsStatic(P6.Changed) then
+    begin
+        Result := TMyc3Mutable<T>.CreateMutable(
+        [P1.Changed, P2.Changed, P3.Changed, P4.Changed, P5.Changed, P6.Changed],
+            function: T
+            begin
+                Result := Calculator( P1.Value, P2.Value, P3.Value, P4.Value, P5.Value, P6.Value );
+            end );
+    end
+    else
+        Result := TMyc3ConstantMutable<T>.Create( Calculator( P1.Value, P2.Value, P3.Value, P4.Value, P5.Value, P6.Value ) );
+end;
+
+class function TValue<T>.CreateMutable<U, V, W, X, Y>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; P3: IMyc3Mutable<W>; P4: IMyc3Mutable<X>;
+P5: IMyc3Mutable<Y>; Calculator: TFunc<U, V, W, X, Y, T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( P1 ) and Assigned( P2 ) and Assigned( P3 ) and Assigned( P4 ) and Assigned( P5 ) );
+
+    if not Signals.IsStatic(P1.Changed) or not Signals.IsStatic(P2.Changed) or not Signals.IsStatic(P3.Changed)
+        or not Signals.IsStatic(P4.Changed) or not Signals.IsStatic(P5.Changed) then
+    begin
+        Result := TMyc3Mutable<T>.CreateMutable(
+        [P1.Changed, P2.Changed, P3.Changed, P4.Changed, P5.Changed],
+            function: T
+            begin
+                Result := Calculator( P1.Value, P2.Value, P3.Value, P4.Value, P5.Value );
+            end );
+    end
+    else
+        Result := TMyc3ConstantMutable<T>.Create( Calculator( P1.Value, P2.Value, P3.Value, P4.Value, P5.Value ) );
+end;
+
+class function TValue<T>.CreateMutable<U, V>( P1: IMyc3Mutable<U>; P2: IMyc3Mutable<V>; Calculator: TFunc<U, V, T> )
+: IMyc3Mutable<T>;
+begin
+    Assert( Assigned( P1 ) and Assigned( P1 ) );
+
+    if not Signals.IsStatic(P1.Changed) or not Signals.IsStatic(P2.Changed) then
+    begin
+        Result := TMyc3Mutable<T>.CreateMutable(
+        [P1.Changed, P2.Changed],
+            function: T
+            begin
+                Result := Calculator( P1.Value, P2.Value );
+            end );
+    end
+    else
+        Result := TMyc3ConstantMutable<T>.Create( Calculator( P1.Value, P2.Value ) );
+end;
+
+class function TValue<T>.CreateMutable<U>( P: IMyc3Mutable<U>; Calculator: TFunc<U, T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( P ) );
+
+    if not Signals.IsStatic(P.Changed) then
+    begin
+        Result := TMyc3Mutable<T>.CreateMutable(
+            P.Changed,
+            function: T
+            begin
+                Result := Calculator( P.Value );
+            end );
+    end
+    else
+        Result := TMyc3ConstantMutable<T>.Create( Calculator( P.Value ) );
+end;
+
+class function TValue<T>.CreateWriteable( const InitValue: T ): IMyc3Writeable<T>;
+begin
+    Result := TMyc3Writeable<T>.CreateWriteable( InitValue );
+end;
+
+class function TValue<T>.CreatePropertyEx( const Decorated: IMyc3Mutable<T> ): IMyc3Property<T>;
+begin
+    Result := TMycProperty<T>.CreateProperty( Decorated );
+end;
+
+class function TValue<T>.CreateProperty( const Creator: TFunc < IMyc3Mutable < T >> ): IMyc3MutablePropertyEx<T>;
+begin
+    Result := TMyc3MutablePropertyEx<T>.Create( Creator );
+end;
+
+class function TValue<T>.CreateMutableProperty(const InitValue: IMyc3Mutable<T>): IMyc3MutableProperty<T>;
+begin
+    Result := TMyc3MutableProperty<T>.Create( InitValue );
+end;
+
+class function TValue<T>.CreateSet: IMycSet<T>;
+begin
+    Result := TMycSet<T>.Create;
+end;
+
+class function TValue<T>.CreateWriteable( const InitValue: T; const EqualityComparison: TEqualityComparison<T> )
+: IMyc3Writeable<T>;
+begin
+    Result := TMyc3Writeable<T>.CreateWriteable( InitValue, EqualityComparison );
+end;
+
+class function TValue<T>.CreateWriteable: IMyc3Writeable<T>;
+begin
+    Result := CreateWriteable( Default(T) );
+end;
+
+class function TValue<T>.Execute( Future: IMyc3Future<T>; Proc: TConstFunc<T, IMyc2Signal> ): IMyc2State;
+begin
+    Result := Tasks.Start( Future.Initialized,
+        function: IMyc2Signal
+        begin
+            Result := Proc( Future.Value );
+        end );
+end;
+
+class function TValue<T>.GetDefaultFuture: IMyc3Future<T>;
+begin
+    Result := TMyc3Future<T>.DefaultFuture;
+end;
+
+class function TValue<T>.MakeValid( const Value: IMyc3Future<T> ): IMyc3Future<T>;
+begin
+    Result := Value;
+    if Result = nil then
+        Result := DefaultFuture;
+end;
+
+class function TValue<T>.MakeValid( const Value: IMyc3Mutable<T> ): IMyc3Mutable<T>;
+begin
+    Result := Value;
+    if Result = nil then
+        Result := DefaultMutable;
+end;
+
+class function TValue<T>.TryGetValue( const Future: IMyc3Future<T>; out Value: T ): Boolean;
+begin
+    Result := Future <> nil;
+    if Result then
+    begin
+        Result := Future.Initialized = Signals.Null.State;
+        if Result then
+        begin
+            Result := Future.Initialized.IsSet;
+            if Result then
+                Value := Future.Value;
+        end;
+    end;
+end;
+
+class function TValue<T>.WaitFor( Future: IMyc3Future<T> ): T;
+begin
+    Tasks.WaitFor( Future.Initialized );
+    exit( Future.Value );
+end;
+
+class procedure TValue<T>.WaitFor( const Futures: TArray<IMyc3Future<T>>; Exec: TProc<Integer, T> );
+var
+    i: Integer;
+    Arr: TArray<IMyc3Future<T>>;
+begin
+    SetLength( Arr, Length( Futures ) );
+    for i := 0 to High( Futures ) do
+        if Futures[i].Initialized.IsSet then
+            Exec( i, Futures[i].Value )
+        else
+            Arr[i] := Futures[i];
+
+    for i := 0 to High( Arr ) do
+        if Arr[i] <> nil then
+            Exec( i, WaitFor( Futures[i] ) );
+end;
+
+{ TMyc2ComputeProperty<T> }
+
+constructor TMyc2ComputeProperty<T>.Create( const StartSignal: IMyc2Signal; const Creator: TFunc<T> );
+var
+    P: ^T;
+begin
+    FValue := default ( T );
+    P := @FValue;
+    FDone := Tasks.Start( StartSignal,
+        procedure
+        begin
+            P^ := Creator( );
+        end );
+end;
+
+procedure TMyc2ComputeProperty<T>.Terminate;
+begin
+    if FDone <> Signals.Null.State then
+    begin
+        Tasks.WaitFor( FDone );
+        FDone := Signals.Null.State;
+    end;
+end;
+
+function TMyc2ComputeProperty<T>.Value: T;
+begin
+    Terminate;
+    Result := FValue;
+end;
+
+{ Signals }
+
+class function Signals.CreateCounter( Count: Integer ): IMyc2Condition;
+begin
+    Result := TMyc2Signal.CreateCounter( Count )
+end;
+
+class function Signals.CreateEvent( Init: Boolean = false ): IMyc2Event;
+begin
+    Result := TMyc2Signal.CreateEvent( Init );
+end;
+
+class function Signals.CreateNotifier: IMyc2Notifier;
+begin
+    Result := TMyc2Signal.CreateNotifier;
+end;
+
+class function Signals.CreateSink(Once: Boolean; const Proc: TProc): IMyc2Sink;
+begin
+    Result := TMyc2SinkProc.CreateSink( Once, Proc );
+end;
+
+class function Signals.Concat( const States: array of IMyc2State ): IMyc2State;
+begin
+    Result := TMyc2Signal.CreateConcat( States );
+end;
+
+class function Signals.CreateObserver<T>( const Signals: array of IMyc2Signal; const Sink: T ): IMycObserver<T>;
+begin
+    Result := TMycObserver<T>.CreateObserver( Signals, Sink );
+end;
+
+class function Signals.CreateEventObserver( const Signals: array of IMyc2Signal ): IMycEventObserver;
+begin
+    Result := CreateObserver<IMyc2Event>( Signals, CreateEvent( True ) );
+end;
+
+class function Signals.CreateNotifyObserver( const Signals: array of IMyc2Signal ): IMycNotifyObserver;
+begin
+    Result := CreateObserver<IMyc2Notifier>( Signals, CreateNotifier );
+end;
+
+class function Signals.CreateNotifyObserver( const Signals: IMycCountable<IMyc2Signal> ): IMycNotifyObserver;
+var
+    Arr: TArray<IMyc2Signal>;
+    i: Integer;
+begin
+    SetLength( Arr, Signals.Count );
+    for i := 0 to High( Arr ) do
+        Arr[i] := Signals[i];
+
+    Result := CreateNotifyObserver( Arr );
+end;
+
+class function Signals.CreateEventObserver( const Signals: IMycCountable<IMyc2Signal> ): IMycEventObserver;
+var
+    Arr: TArray<IMyc2Signal>;
+    i: Integer;
+begin
+    SetLength( Arr, Signals.Count );
+    for i := 0 to High( Arr ) do
+        Arr[i] := Signals[i];
+
+    Result := CreateEventObserver( Arr );
+end;
+
+class function Signals.CreateFlag(Init: Boolean): IMyc2Flag;
+begin
+    Result := TMyc2Flag.Create( Init );
+end;
+
+class function Signals.CreateSink(const Proc: TProc): IMyc2Sink;
+begin
+    Result := TMyc2SinkProc.CreateSink( false, Proc );
+end;
+
+class function Signals.GetNull: IMyc2Condition;
+begin
+    exit( TMyc2Signal.Null );
+end;
+
+class function Signals.IsStatic( const Signal: IMyc2Signal ): Boolean;
+begin
+    Result := ( Signal = nil ) or ( Signal = Null.State );
+end;
+
+class function Signals.MakeValid( const Signal: IMyc2Signal ): IMyc2Signal;
+begin
+    if IsStatic( Signal ) then
+        exit( Null.State )
+    else
+        exit( Signal );
+end;
+
+class function Signals.MakeValid( const Signals: array of IMyc2Signal ): TArray<IMyc2Signal>;
+begin
+    Result := TMyc2Signal.MakeValid( Signals );
+end;
+
+class function Signals.Union( const Sigs: array of IMyc2Signal ): IMyc2Signal;
+begin
+    Result := TMyc2Signal.CreateUnion( Sigs );
+end;
+
+{ TState }
+
+class function TAtomicStack<T>.Create: IAtomicStack<T>;
+begin
+    Result := TMycAtomicStack<T>.Create;
+end;
+
+{ TProtected<T> }
+
+constructor TProtected<T>.Create( const AItem: T );
+begin
+    FItem := AItem;
+end;
+
+function TProtected<T>.Exchange( const Value: T ): T;
+begin
+    if Value <> nil then
+        Value._AddRef;
+
+    PPointer( @Result )^ := TInterlocked.Exchange( PPointer( @FItem )^, PPointer( @Value )^ );
+end;
+
+class operator TProtected<T>.Implicit( const Value: T ): TProtected<T>;
+begin
+    Result.Create( Value );
+end;
+
+{ Mutable }
+
+class function Mutable.ConvertSet<T, S>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>; const Converter: TFunc<T, S>): IMyc3Mutable<
+    TArray< IMyc3Mutable<S>>>;
+begin
+    Result := TValue<TArray<IMyc3Mutable<S>>>.CreateMutable<TArray<IMyc3Mutable<T>>>(
+        Arr,
+        function( Arr: TArray<IMyc3Mutable<T>> ): TArray<IMyc3Mutable<S>>
+        var
+            i: Integer;
+        begin
+            SetLength( Result, Length(Arr) );
+            for i := 0 to High(Result) do
+            begin
+                Assert( Arr[i] <> nil );
+                Result[i] := TValue<S>.CreateMutable<T>( Arr[i], Converter );
+            end;
+        end );
+end;
+
+class function Mutable.ConvertSet<T, S>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>; const Converter: TFunc<T, S>):
+    IMyc3Mutable<TArray< IMyc3Mutable<IMyc3Future<S>>>>;
+begin
+    Result := ConvertSet<IMyc3Future<T>, IMyc3Future<S>>(
+        Arr,
+        function( Item: IMyc3Future<T> ): IMyc3Future<S>
+        begin
+            Assert( Item <> nil );
+            Result := TValue<S>.CreateFuture<T>( Item, Converter );
+        end );
+end;
+
+class function Mutable.Create( Value: Boolean ): IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableBoolean.CreateBoolean( Value );
+end;
+
+class function Mutable.CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>): IMyc3Mutable<TArray<T>>;
+begin
+    Result :=
+        Mutable.From<TArray<IMyc3Mutable<T>>, TArray<T>>(
+            Arr,
+            function( Arr: TArray<IMyc3Mutable<T>> ): IMyc3Mutable<TArray<T>>
+            begin
+                Result := TValue<T>.CreateMutable( Arr );
+            end );
+end;
+
+class function Mutable.CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>): IMyc3Mutable<IMyc3Future<TArray<T>>>;
+begin
+    Result :=
+        Mutable.From<TArray<IMyc3Mutable<IMyc3Future<T>>>, IMyc3Future<TArray<T>>>(
+            Arr,
+            function( Arr: TArray<IMyc3Mutable<IMyc3Future<T>>> ): IMyc3Mutable<IMyc3Future<TArray<T>>>
+            begin
+                Result := TMutableFuture.FromArray<T>( Arr );
+            end );
+end;
+
+class function Mutable.CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>; const Creator: TFunc<TArray<T>, T>): IMyc3Mutable<T>;
+begin
+    Result := TValue<T>.AsMutable(
+        TValue<IMyc3Mutable<T>>.CreateMutable<TArray<IMyc3Mutable<T>>>(
+            Arr,
+            function( Arr: TArray<IMyc3Mutable<T>> ): IMyc3Mutable<T>
+            begin
+                Result := TValue<T>.CreateMutable<TArray<T>>( TValue<T>.CreateMutable( Arr ), Creator ) ;
+            end ) );
+end;
+
+class function Mutable.CreateAssembly<T, S>(
+  const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>;
+  const Creator: TFunc<TArray<T>, S>): IMyc3Mutable<IMyc3Future<S>>;
+begin
+    Result := CreateAssembly<IMyc3Future<T>, IMyc3Future<S>>( Arr,
+        function( Arr: TArray<IMyc3Future<T>> ): IMyc3Future<S>
+        begin
+            Result := TValue<S>.CreateFuture<TArray<T>>( TValue<T>.CreateFuture( Arr ), Creator );
+        end );
+end;
+
+class function Mutable.CreateAssembly<T, S>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<T>>>; const Creator: TFunc<TArray<T>, S>):
+    IMyc3Mutable<S>;
+begin
+    Result := TValue<S>.AsMutable(
+        TValue<IMyc3Mutable<S>>.CreateMutable<TArray<IMyc3Mutable<T>>>(
+            Arr,
+            function( Arr: TArray<IMyc3Mutable<T>> ): IMyc3Mutable<S>
+            begin
+                Result := TValue<S>.CreateMutable<TArray<T>>( TValue<T>.CreateMutable( Arr ), Creator ) ;
+            end ) );
+end;
+
+class function Mutable.CreateAssembly<T>(const Arr: IMyc3Mutable<TArray<IMyc3Mutable<IMyc3Future<T>>>>; const Creator: TFunc<TArray<T>, T>)
+    : IMyc3Mutable<IMyc3Future<T>>;
+begin
+    Result := CreateAssembly<IMyc3Future<T>>( Arr,
+        function( Arr: TArray<IMyc3Future<T>> ): IMyc3Future<T>
+        begin
+            Result := TValue<T>.CreateFuture<TArray<T>>( TValue<T>.CreateFuture( Arr ), Creator );
+        end );
+end;
+
+class function Mutable.FromSignal(const Signal: IMyc2Signal): IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableSignal.Create( Signal );
+end;
+
+class function Mutable.CreateOverride<T>(const Value, Ovrride: IMyc3Mutable<TImmutable<T>>): IMyc3Mutable<TImmutable<T>>;
+begin
+    Result := TValue<TImmutable<T>>.CreateMutable<TImmutable<T>, TImmutable<T>>(
+        Value, Ovrride,
+        function( Value, Ovrride: TImmutable<T> ): TImmutable<T>
+        begin
+            if not Ovrride.HasValue then
+                Result := Value
+            else
+                Result := Ovrride;
+        end );
+end;
+
+class function Mutable.CreateCache<T>( const Comparer: IComparer<T> = nil ): TMutableCache<T>;
+begin
+    Result.Create( TMycMutableTable<T>.Create( Comparer ) );
+end;
+
+class function Mutable.CreateNotifyObserver<T>(const Mutables: TArray<IMyc3Mutable<T>>): IMycNotifyObserver;
+var
+    Sigs: TArray<IMyc2Signal>;
+    i: Integer;
+begin
+    SetLength( Sigs, Length(Mutables) );
+    for i := 0 to High(Sigs) do
+        Sigs[i] := Mutables[i].Changed;
+    Result := Signals.CreateNotifyObserver(Sigs);
+end;
+
+class function Mutable.CreateEventObserver<T>(const Mutables: TArray<IMyc3Mutable<T>>): IMycEventObserver;
+var
+    Sigs: TArray<IMyc2Signal>;
+    i: Integer;
+begin
+    SetLength( Sigs, Length(Mutables) );
+    for i := 0 to High(Sigs) do
+        Sigs[i] := Mutables[i].Changed;
+    Result := Signals.CreateEventObserver(Sigs);
+end;
+
+class function Mutable.CreateValidator<T>( const Comparer: IComparer<T> = nil ): IMyc3MutableCache<T>;
+begin
+    Result := TMycMutableCache<T>.CreateCache( Comparer );
+end;
+
+class function Mutable.ExtractSignals<T>(const Mutables: TArray<IMyc3Mutable<T>>): IMyc2Signal;
+var
+    i: Integer;
+    Arr: TArray<IMyc2Signal>;
+begin
+    SetLength( Arr, Length(Mutables) );
+    for i := 0 to High(Arr) do
+        Arr[i] := Mutables[i].Changed;
+    Result := Signals.Union( Arr );
+end;
+
+class function Mutable.False: IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableBoolean.CreateBoolean( System.False );
+end;
+
+class function Mutable.From<S, T>(const Value: IMyc3Mutable<S>; const Conv: TFunc<S, IMyc3Mutable<T>>): IMyc3Mutable<T>;
+begin
+    Result := TMyc3EnclosedMutable<T>.Create(
+        TValue<IMyc3Mutable<T>>.CreateMutable<S>( Value, Conv ) );
+end;
+
+class function Mutable.Convert<S, T>(const Value: IMyc3Mutable<S>; const Conv: TFunc<S, T>): IMyc3Mutable<T>;
+begin
+    Result := TValue<T>.CreateMutable<S>( Value, Conv );
+end;
+
+class function Mutable.Convert<S, T>(const Value: IMyc3Mutable<IMyc3Future<S>>; const Conv: TFunc<S, T>): IMyc3Mutable<IMyc3Future<T>>;
+begin
+    Result := Convert<IMyc3Future<S>, IMyc3Future<T>>(
+        Value,
+        function( Value: IMyc3Future<S> ): IMyc3Future<T>
+        begin
+            Result := TFuture.From<S, T>( Value, Conv )
+        end );
+end;
+
+class function Mutable.Convert<S, T>(const Value: IMyc3Mutable<IMyc3Future<S>>; const Conv: TFunc<S, IMyc3Future<T>>): IMyc3Mutable<IMyc3Future<T>>;
+begin
+    Result := Convert<IMyc3Future<S>, IMyc3Future<T>>(
+        Value,
+        function( Value: IMyc3Future<S> ): IMyc3Future<T>
+        begin
+            Result := TFuture.From<S, T>( Value, Conv )
+        end );
+end;
+
+class function Mutable.CreateNullable<T>: IMyc3Writeable<TImmutable<T>>;
+begin
+    Result := TValue<TImmutable<T>>.CreateWriteable( TImmutable<T>.Null );
+end;
+
+class function Mutable.CreateObjectLink<T>(Obj: T): IMyc3ObjectLink<T>;
+begin
+    Result := TMyc3ObjectLink<T>.Create( Obj );
+end;
+
+class function Mutable.TrimArray<T>(const Values: IMyc3Mutable<TArray<T>>): IMyc3Mutable<TArray<T>>;
+begin
+    Result := TValue<TArray<T>>.CreateMutable<TArray<T>>(
+        Values,
+        function( Values: TArray<T> ): TArray<T>
+        var
+            i, n: Integer;
+        begin
+            n := 0;
+            for i := 0 to High(Values) do
+                if Assigned(Values[i]) then
+                    inc(n);
+
+            SetLength( Result, n );
+            n := 0;
+            for i := 0 to High(Values) do
+            begin
+                Result[n] := Values[i];
+                inc(n);
+            end;
+        end );
+end;
+
+class function Mutable.FilterArray<T>(const Values: IMyc3Mutable<TArray<T>>; const FilterFunc: TConstFunc<T, IMyc3Mutable<Boolean>>): IMyc3Mutable<TArray<T>>;
+var
+    Sieve: IMyc3Mutable<TArray<IMyc3Mutable<Boolean>>>;
+begin
+    Sieve := TValue<TArray<IMyc3Mutable<Boolean>>>.CreateMutable<TArray<T>>(
+        Values,
+        function( Values: TArray<T> ): TArray<IMyc3Mutable<Boolean>>
+        var
+            i: Integer;
+        begin
+            SetLength( Result, Length( Values ) );
+            for i := 0 to High(Values) do
+                Result[i] := FilterFunc( Values[i] );
+        end );
+
+    Result := TValue<TArray<T>>.CreateMutable<TArray<Boolean>, TArray<T>>(
+        Mutable.CreateAssembly<Boolean>( Sieve ),
+        Values,
+        function( Sieve: TArray<Boolean>; GeoArr: TArray<T> ): TArray<T>
+        var
+            i, n: Integer;
+        begin
+            n := 0;
+            for i := 0 to High(GeoArr) do
+                if Sieve[i] then
+                    inc( n );
+            SetLength( Result, n );
+            n := 0;
+            for i := 0 to High(GeoArr) do
+                if Sieve[i] then
+                begin
+                    Result[n] := GeoArr[i];
+                    inc(n);
+                end;
+        end );
+end;
+
+class function Mutable.From<R, S, T>(const ValueR: IMyc3Mutable<R>; const ValueS: IMyc3Mutable<S>; const Conv: TFunc<R, S, IMyc3Mutable<T>>): IMyc3Mutable<T>;
+begin
+    Result := TMyc3EnclosedMutable<T>.Create(
+        TValue<IMyc3Mutable<T>>.CreateMutable<R, S>( ValueR, ValueS, Conv ) );
+end;
+
+class function Mutable.From<T>(const Value: T): IMyc3Mutable<T>;
+begin
+    Result := TMyc3ConstantMutable<T>.Create( Value );
+end;
+
+class function Mutable.FromArray<S, T>(const Value: IMyc3Mutable<TArray<S>>; const Conv: TFunc<S, T>): IMyc3Mutable<TArray<T>>;
+begin
+    Result :=
+        Convert<TArray<S>, TArray<T>>( Value,
+            function( Arr: TArray<S> ): TArray<T>
+            var
+                i: Integer;
+            begin
+                SetLength( Result, Length(Arr) );
+                for i := 0 to High(Arr) do
+                    Result[i] := Conv( Arr[i] );
+            end );
+end;
+
+class function Mutable.FromArray<S, T>(const Value: IMyc3Mutable<TArray<S>>; const Conv: TFunc<S, IMyc3Mutable<T>>): IMyc3Mutable<TArray<T>>;
+begin
+    Result := CreateAssembly<T>( FromArray<S, IMyc3Mutable<T>>( Value, Conv ) );
+end;
+
+class function Mutable.FromArray<T>(const Value: TArray<IMyc3Mutable<T>>): IMyc3Mutable<TArray<T>>;
+begin
+    Result := TMyc3MutableArray<T, T>.Create(
+        Value,
+        function( Idx: Integer; Val: T ): T
+        begin
+            Result := Val;
+        end );
+end;
+
+class function Mutable.FromState(const State: IMyc2State): IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableState.Create( State );
+end;
+
+class function Mutable.IfNotThen<T>(const Condition: IMyc3Mutable<Boolean>; const FalseValue: IMyc3Mutable<T>): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( Condition ) and Assigned( FalseValue ) );
+
+    if Signals.IsStatic(Condition.Changed) then
+    begin
+        if Condition.Value then
+            exit( TValue<T>.DefaultMutable )
+        else
+            exit( FalseValue );
+    end;
+
+    Result := TMyc3Mutable<T>.CreateMutable(
+    [Condition.Changed, FalseValue.Changed],
+        function: T
+        begin
+            if Condition.Value then
+                Result := System.Default( T )
+            else
+                Result := FalseValue.Value;
+        end );
+end;
+
+class function Mutable.IfThen<T>(const Condition: IMyc3Mutable<Boolean>; const TrueValue: IMyc3Mutable<T>): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( Condition ) and Assigned( TrueValue ) );
+
+    if Signals.IsStatic(Condition.Changed) then
+    begin
+        if Condition.Value then
+            exit( TrueValue )
+        else
+            exit( TValue<T>.DefaultMutable );
+    end;
+
+    Result := TMyc3Mutable<T>.CreateMutable(
+    [Condition.Changed, TrueValue.Changed],
+        function: T
+        begin
+            if Condition.Value then
+                Result := TrueValue.Value
+            else
+                Result := System.Default( T );
+        end );
+end;
+
+class function Mutable.IfThen<T>(const Condition: IMyc3Mutable<Boolean>; const TrueValue: IMyc3Mutable<IMyc3Future<T>>): IMyc3Mutable<
+    IMyc3Future<T>>;
+begin
+    Result := IfThenElse<IMyc3Future<T>>( Condition, TrueValue, TValue<T>.DefaultMutableFuture );
+end;
+
+class function Mutable.IfThenElse<T>(const Condition: IMyc3Mutable<Boolean>; const TrueValue, FalseValue: IMyc3Mutable<T>): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( Condition ) and Assigned( TrueValue ) and Assigned( FalseValue ) );
+
+    Result := TMyc3Mutable<T>.CreateMutable(
+    [Condition.Changed, TrueValue.Changed, FalseValue.Changed],
+        function: T
+        begin
+            if Condition.Value then
+                Result := TrueValue.Value
+            else
+                Result := FalseValue.Value;
+        end );
+end;
+
+class function Mutable.Merge<T>(const Parts: IMyc3Mutable<TArray<TArray<T>>>): IMyc3Mutable<TArray<T>>;
+begin
+    Result := TValue<TArray<T>>.CreateMutable<TArray<TArray<T>>>(
+        Parts,
+        function( Parts: TArray<TArray<T>> ): TArray<T>
+        begin
+            Result := TFuture.Merge<T>( Parts );
+        end );
+end;
+
+class function Mutable.Merge<T>(const Parts: IMyc3Mutable<TArray<IMyc3Future<TArray<T>>>>): IMyc3Mutable<IMyc3Future<TArray<T>>>;
+begin
+    Result := TValue<IMyc3Future<TArray<T>>>.CreateMutable<TArray<IMyc3Future<TArray<T>>>>(
+        Parts,
+        function( Parts: TArray<IMyc3Future<TArray<T>>> ): IMyc3Future<TArray<T>>
+        begin
+            Result := TFuture.Merge<T>( Parts );
+        end );
+end;
+
+class function Mutable.OpAND(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>;
+begin
+    if Length(Arr)=2 then
+        Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+            Arr[0], Arr[1],
+            function( A, B: Boolean ): Boolean
+            begin
+                Result := A and B;
+            end )
+    else if Length(Arr)=1 then
+        Result := Arr[0]
+    else
+        Result := TValue<Boolean>.CreateMutable<TArray<Boolean>>(
+            TValue<Boolean>.CreateMutable(Arr),
+            function( Arr: TArray<Boolean> ): Boolean
+            var
+                i: Integer;
+            begin
+                for i := 0 to High(Arr) do
+                    if not Arr[i] then
+                        exit( System.False );
+                exit( System.true );
+            end );
+end;
+
+class function Mutable.OpNOT(const A: IMyc3Mutable<Boolean>): IMyc3Mutable<Boolean>;
+begin
+    Result := TValue<Boolean>.CreateMutable<Boolean>(
+        A,
+        function( A: Boolean ): Boolean
+        begin
+            Result := not A;
+        end );
+end;
+
+class function Mutable.OpNOR(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>;
+begin
+    if Length(Arr)=2 then
+        Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+            Arr[0], Arr[1],
+            function( A, B: Boolean ): Boolean
+            begin
+                Result := not (A or B);
+            end )
+    else if Length(Arr)=1 then
+        Result := OpNOT( Arr[0] )
+    else
+        Result := TValue<Boolean>.CreateMutable<TArray<Boolean>>(
+            TValue<Boolean>.CreateMutable(Arr),
+            function( Arr: TArray<Boolean> ): Boolean
+            var
+                i: Integer;
+            begin
+                for i := 0 to High(Arr) do
+                    if not Arr[i] then
+                        exit( System.true );
+                exit( System.False );
+            end );
+end;
+
+class function Mutable.OpNAND(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>;
+begin
+    if Length(Arr)=2 then
+        Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+            Arr[0], Arr[1],
+            function( A, B: Boolean ): Boolean
+            begin
+                Result := not (A and B);
+            end )
+    else if Length(Arr)=1 then
+        Result := OpNOT( Arr[0] )
+    else
+        Result := TValue<Boolean>.CreateMutable<TArray<Boolean>>(
+            TValue<Boolean>.CreateMutable(Arr),
+            function( Arr: TArray<Boolean> ): Boolean
+            var
+                i: Integer;
+            begin
+                for i := 0 to High(Arr) do
+                    if not Arr[i] then
+                        exit( System.true );
+                exit( System.False );
+            end );
+end;
+
+class function Mutable.OpOR(const Arr: TArray<IMyc3Mutable<Boolean>>): IMyc3Mutable<Boolean>;
+begin
+    if Length(Arr)=2 then
+        Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+            Arr[0], Arr[1],
+            function( A, B: Boolean ): Boolean
+            begin
+                Result := A or B;
+            end )
+    else if Length(Arr)=1 then
+        Result := Arr[0]
+    else
+        Result := TValue<Boolean>.CreateMutable<TArray<Boolean>>(
+            TValue<Boolean>.CreateMutable(Arr),
+            function( Arr: TArray<Boolean> ): Boolean
+            var
+                i: Integer;
+            begin
+                for i := 0 to High(Arr) do
+                    if Arr[i] then
+                        exit( System.true );
+                exit( System.False );
+            end );
+end;
+
+class function Mutable.SortArray<T>(const Values: IMyc3Mutable<TArray<T>>; const Comparer: IComparer<T>): IMyc3Mutable<TArray<T>>;
+var
+    Cmp: IComparer<T>;
+begin
+    Cmp := Comparer;
+    if not Assigned(Cmp) then
+        Cmp := TComparer<T>.Default;
+
+    Result := TValue<TArray<T>>.CreateMutable<TArray<T>>(
+        Values,
+        function( Values: TArray<T> ): TArray<T>
+        begin
+            SetLength( Result, Length(Values) );
+            TArray.Copy<T>( Values, Result, Length(Values) );
+            TArray.Sort<T>( Result, Cmp );
+        end );
+end;
+
+class function Mutable.True: IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableBoolean.CreateBoolean( System.True );
+end;
+
+class function Mutable<T>.GetComparer: IComparer<IMyc3Mutable<T>>;
+begin
+    Result := TMyc3Mutable<T>.Comparer;
+end;
+
+class function Mutable<T>.CreateArray( const Arr: TArray<IMyc3Mutable<T>> ): IMyc3Mutable<TArray<T>>;
+begin
+    Result := TMyc3Mutable<T>.CreateArray( Arr );
+end;
+
+class function Mutable<T>.CreateArray<S>( const Arr: IMyc3Mutable<TArray<S>>; Calculator: TFunc<S, T> ): IMyc3Mutable<TArray<T>>;
+begin
+    Result := TMyc3Mutable<TArray<T>>.CreateMutable(
+    [Arr.Changed],
+        function: TArray<T>
+        var
+            i: Integer;
+        begin
+            SetLength( Result, Length( Arr.Value ) );
+            for i := 0 to High( Arr.Value ) do
+                Result[i] := Calculator( Arr.Value[i] );
+        end );
+end;
+
+class function Mutable<T>.Default: IMyc3Mutable<T>;
+begin
+    Result := TValue<T>.DefaultMutable;
+end;
+
+class function Mutable<T>.IfThen( const Condition: IMyc3Mutable<Boolean>; const TrueValue: IMyc3Mutable<T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( Condition ) and Assigned( TrueValue ) );
+
+    if Condition = Mutable.True then
+        exit( TrueValue )
+    else if Condition = Mutable.False then
+        exit( default );
+
+    Result := TMyc3Mutable<T>.CreateMutable(
+    [Condition.Changed, TrueValue.Changed],
+        function: T
+        begin
+            if Condition.Value then
+                Result := TrueValue.Value
+            else
+                Result := System.Default( T );
+        end );
+end;
+
+class function Mutable<T>.IfNotThen( const Condition: IMyc3Mutable<Boolean>; const FalseValue: IMyc3Mutable<T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( Condition ) and Assigned( FalseValue ) );
+
+    if Condition = Mutable.True then
+        exit( default )
+    else if Condition = Mutable.False then
+        exit( FalseValue );
+
+    Result := TMyc3Mutable<T>.CreateMutable(
+    [Condition.Changed, FalseValue.Changed],
+        function: T
+        begin
+            if Condition.Value then
+                Result := System.Default( T )
+            else
+                Result := FalseValue.Value;
+        end );
+end;
+
+class function Mutable<T>.IfThenElse( const Condition: IMyc3Mutable<Boolean>; const TrueValue, FalseValue: IMyc3Mutable<T> ): IMyc3Mutable<T>;
+begin
+    Assert( Assigned( Condition ) and Assigned( TrueValue ) and Assigned( FalseValue ) );
+
+    if Condition = Mutable.True then
+        exit( TrueValue );
+    if Condition = Mutable.False then
+        exit( FalseValue );
+    if TrueValue = default then
+        exit( IfNotThen( Condition, FalseValue ) );
+    if FalseValue = default then
+        exit( IfThen( Condition, TrueValue ) );
+
+    Result := TMyc3Mutable<T>.CreateMutable(
+    [Condition.Changed, TrueValue.Changed, FalseValue.Changed],
+        function: T
+        begin
+            if Condition.Value then
+                Result := TrueValue.Value
+            else
+                Result := FalseValue.Value;
+        end );
+end;
+
+{ TMutableBool }
+
+constructor TMutableBool.Create(const AThis: IMyc3Mutable<Boolean>);
+begin
+    FThis := AThis;
+end;
+
+class function TMutableBool.GetDefaults(Value: Boolean): IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableBoolean.CreateBoolean( Value );
+end;
+
+class function TMutableBool.True: IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableBoolean.CreateBoolean( System.true );
+end;
+
+class function TMutableBool.False: IMyc3Mutable<Boolean>;
+begin
+    Result := TMycMutableBoolean.CreateBoolean( System.false );
+end;
+
+class operator TMutableBool.Equal(const A, B: TMutableBool): TMutableBool;
+begin
+    Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+        A, B,
+        function( A, B: Boolean ): Boolean
+        begin
+            Result := A = B;
+        end );
+end;
+
+class operator TMutableBool.Implicit(const Value: IMyc3Mutable<Boolean>): TMutableBool;
+begin
+    Result.Create( Value );
+end;
+
+class operator TMutableBool.Implicit(const Value: TMutableBool): IMyc3Mutable<Boolean>;
+begin
+    Result := Value.This;
+end;
+
+class operator TMutableBool.LogicalAnd(const A, B: TMutableBool): TMutableBool;
+begin
+    Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+        A, B,
+        function( A, B: Boolean ): Boolean
+        begin
+            Result := A and B;
+        end );
+end;
+
+class operator TMutableBool.LogicalNot(const Value: TMutableBool): TMutableBool;
+begin
+    Result := TValue<Boolean>.CreateMutable<Boolean>(
+        Value,
+        function( Value: Boolean ): Boolean
+        begin
+            Result := not Value;
+        end );
+end;
+
+class operator TMutableBool.LogicalOr(const A, B: TMutableBool): TMutableBool;
+begin
+    Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+        A, B,
+        function( A, B: Boolean ): Boolean
+        begin
+            Result := A or B;
+        end );
+end;
+
+class operator TMutableBool.NotEqual(const A, B: TMutableBool): TMutableBool;
+begin
+    Result := TValue<Boolean>.CreateMutable<Boolean, Boolean>(
+        A, B,
+        function( A, B: Boolean ): Boolean
+        begin
+            Result := A <> B;
+        end );
+end;
+
+{ TAssembly<T> }
+
+class function TAssembly<T>.Create: IMycAssembly<T>;
+begin
+    Result := TMycAssembly<T>.Create;
+end;
+
+{ TMycArray<T> }
+
+class function TMycArray.Create<T>( const Arr: array of T ): IMycArray<T>;
+begin
+    Result := TMycCustomArray<T>.CreateArray( Arr );
+end;
+
+class function TMycArray.Create<T>( Count: Integer; const Getter: TFunc<Integer, T> ): IMycArray<T>;
+begin
+    Result := TMycGenericArray<T>.Create( Count, Getter );
+end;
+
+class function TMycArray.Create<S, T>( const Src: IMycArray<S>; const Converter: TConstFunc<S, T> ): IMycArray<T>;
+begin
+    Result := TMycCustomArray<T>.CreateConvert<S>( Src, Converter );
+end;
+
+class function TMycArray.Create<T>(const Src: IMyc2Enumerable<T>): IMycArray<T>;
+var
+    n: Integer;
+    E: IMycEnumerator<T>;
+    Vals: TArray<T>;
+begin
+    E := Src.GetEnumerator;
+
+    n := 0;
+    while E.MoveNext do
+        inc( n );
+
+    SetLength( Vals, n );
+
+    E.Reset;
+    n := 0;
+    while E.MoveNext do
+    begin
+        Vals[n] := E.Current;
+        inc(n);
+    end;
+
+    Result := TMycCustomArray<T>.CreateArray( Vals );
+end;
+
+class function TMycArray.CreateConvert<T, S>( const Enum: IMyc2Enumerable<S>; const Conv: TConstFunc<S, T> ): IMyc2Enumerable<T>;
+begin
+    Result := TMyc2ConvertEnumerable<T, S>.Create( Enum, Conv );
+end;
+
+class function TMycArray.Divide<T>( const Src: TArray<T>; const Comparer: IComparer<T> ): TArray<TArray<T>>;
+var
+    i: Integer;
+    Arr: TArray<IMycArray<T>>;
+begin
+    Arr := Create<T>( Src ).Divide( Comparer );
+
+    SetLength( Result, Length( Arr ) );
+    for i := 0 to High( Result ) do
+        Result[i] := Arr[i].ToArray;
+end;
+
+class procedure TMycArray.Divide1<TKey, TValue>( const Src: IMycArray<TPair<TKey, TValue>>; out Keys: TArray<TKey>; out Values:
+    TArray<IMycArray<TValue>>; const Comparer: IComparer<TKey> );
+var
+    Arr: TArray<IMycArray<TPair<TKey, TValue>>>;
+    i: Integer;
+begin
+    Arr := Src.Divide(
+        TComparer<TPair<TKey, TValue>>.Construct(
+            function( const A, B: TPair<TKey, TValue> ): Integer
+        begin
+            Result := Comparer.Compare( A.Key, B.Key );
+        end ) );
+
+    SetLength( Keys, Length( Arr ) );
+    SetLength( Values, Length( Arr ) );
+    for i := 0 to High( Arr ) do
+    begin
+        Keys[i] := Arr[i][0].Key;
+
+        Values[i] := TMycCustomArray<TValue>.CreateConvert<TPair<TKey, TValue>>(
+        Arr[i],
+            function( const P: TPair<TKey, TValue> ): TValue
+            begin
+                Result := P.Value;
+            end );
+    end;
+end;
+
+class function TMycArray.Divide<TKey, TValue>( const Src: TArray<TPair<TKey, TValue>>; const Comparer: IComparer<TKey> ): TArray<TPair<TKey,
+    TArray<TValue>>>;
+var
+    i, j: Integer;
+    Arr: TArray<IMycArray<TPair<TKey, TValue>>>;
+begin
+    Arr := Create<TPair<TKey, TValue>>( Src ).Divide(
+    TComparer<TPair<TKey, TValue>>.Construct(
+            function( const A, B: TPair<TKey, TValue> ): Integer
+        begin
+            Result := Comparer.Compare( A.Key, B.Key );
+        end ) );
+
+    SetLength( Result, Length( Arr ) );
+    for i := 0 to High( Result ) do
+    begin
+        Result[i].Key := Arr[i][0].Key;
+        SetLength( Result[i].Value, Arr[i].Count );
+        for j := 0 to High( Result[i].Value ) do
+            Result[i].Value[j] := Arr[i][j].Value;
+    end;
+end;
+
+class function TMycArray.Divide<TKey, TValue>( const Src: IMycArray<TPair<TKey, TValue>>; const Comparer: IComparer<TKey> ):
+    TArray<TPair<TKey, IMycArray<TValue>>>;
+var
+    Arr: TArray<IMycArray<TPair<TKey, TValue>>>;
+    i: Integer;
+begin
+    Arr := Src.Divide(
+    TComparer<TPair<TKey, TValue>>.Construct(
+        function( const A, B: TPair<TKey, TValue> ): Integer
+        begin
+            Result := Comparer.Compare( A.Key, B.Key );
+        end ) );
+
+    SetLength( Result, Length( Arr ) );
+    for i := 0 to High( Result ) do
+    begin
+        Result[i] := TPair<TKey, IMycArray<TValue>>.Create(
+        Arr[i][0].Key,
+            TMycCustomArray<TValue>.CreateConvert<TPair<TKey, TValue>>(
+        Arr[i],
+            function( const P: TPair<TKey, TValue> ): TValue
+            begin
+                Result := P.Value;
+            end ) );
+    end;
+end;
+
+class function TMycArray.GetKeys<TKey, TValue>( const Arr: TArray<TPair<TKey, TValue>> ): TArray<TKey>;
+var
+    i: Integer;
+begin
+    SetLength( Result, Length( Arr ) );
+    for i := 0 to High( Arr ) do
+        Result[i] := Arr[i].Key;
+end;
+
+class function TChain.Create<T>: IMycChain<T>;
+begin
+    Result := TMycChain<T>.Create;
+end;
+
+{ TMutableCache<T> }
+
+constructor TMutableCache<T>.Create( const AThis: IMyc3MutableTable<T> );
+begin
+    FThis := AThis;
+end;
+
+function TMutableCache<T>.GetItem(const Value: T): IMyc3Mutable<T>;
+begin
+    Result := FThis.Add( Value );
+end;
+
+procedure TMutableCache<T>.Clear;
+begin
+    FThis.Clear;
+end;
+
+class function Stack.Create<T>: IMycStack<T>;
+begin
+    Result := TMycStack<T>.Create;
+end;
+
+{ TTag }
+
+class function TTag.From<T>(const Data: T): TTag;
+begin
+    {$ifdef DEBUG}
+    Result.FTypeInfo := TypeInfo(T);
+    Assert( (Result.FTypeInfo<>nil) and (Result.FTypeInfo.Name <> 'TTag'), 'Recursive tag declaration' );
+    {$endif}
+
+    case PTypeInfo(TypeInfo(T)).Kind of
+        tkInteger:
+        begin
+            case PTypeInfo(TypeInfo(T)).TypeData.OrdType of
+                otSByte: PShortInt(@Result.FOrdinal)^ := PShortInt(@Data)^;
+                otUByte: PByte(@Result.FOrdinal)^ := PByte(@Data)^;
+                otSWord: PSmallInt(@Result.FOrdinal)^ := PSmallInt(@Data)^;
+                otUWord: PWord(@Result.FOrdinal)^ := PWord(@Data)^;
+                otSLong: PInteger(@Result.FOrdinal)^ := PInteger(@Data)^;
+                otULong: PLongword(@Result.FOrdinal)^ := PLongword(@Data)^;
+            end;
+        end;
+
+        tkInt64:
+        begin
+            Result.FOrdinal := PInt64(@Data)^;
+        end;
+
+        tkFloat:
+        begin
+            case PTypeInfo(TypeInfo(T)).TypeData.FloatType of
+                ftSingle: PSingle(@Result.FOrdinal)^ := PSingle(@Data)^;
+                ftDouble: PDouble(@Result.FOrdinal)^ := PDouble(@Data)^;
+            else
+                begin
+                    Result.FOrdinal := 0;
+                    Result.FManaged := TMyc3Value<T>.Create(Data);
+                end;
+            end;
+        end;
+
+        {$IFNDEF AUTOREFCOUNT}
+        tkClass,
+        {$ENDIF}
+        tkPointer:
+        begin
+            PPointer(@Result.FOrdinal)^ := PPointer(@Data)^;
+        end;
+
+        tkInterface:
+        begin
+            Result.FOrdinal := 0;
+            Result.FManaged := IInterface(PPointer(@Data)^);
+        end;
+
+    else
+        begin
+            Result.FOrdinal := 0;
+            Result.FManaged := TMyc3Value<T>.Create(Data);
+        end;
+    end;
+end;
+
+function TTag.AsType<T>: T;
+begin
+    {$ifdef DEBUG}
+    if FTypeInfo=nil then
+        RaiseInvalidOperation( 'TTag not initialized, value of type %s expected', [PTypeInfo(TypeInfo(T)).Name] );
+
+    if FTypeInfo <> TypeInfo(T) then
+        RaiseInvalidOperation( 'TTag<%s> can''t cast to %s', [FTypeInfo.Name, PTypeInfo(TypeInfo(T)).Name] );
+    {$endif}
+
+    case PTypeInfo(TypeInfo(T)).Kind of
+        tkInteger:
+        begin
+            case PTypeInfo(TypeInfo(T)).TypeData.OrdType of
+                otSByte: PShortInt(@Result)^ := PShortInt(@FOrdinal)^;
+                otUByte: PByte(@Result)^ := PByte(@FOrdinal)^;
+                otSWord: PSmallInt(@Result)^ := PSmallInt(@FOrdinal)^;
+                otUWord: PWord(@Result)^ := PWord(@FOrdinal)^;
+                otSLong: PInteger(@Result)^ := PInteger(@FOrdinal)^;
+                otULong: PLongword(@Result)^ := PLongword(@FOrdinal)^;
+            end;
+        end;
+
+        tkInt64:
+        begin
+            PInt64(@Result)^ := FOrdinal;
+        end;
+
+        tkFloat:
+        begin
+            case PTypeInfo(TypeInfo(T)).TypeData.FloatType of
+                ftSingle: PSingle(@Result)^ := PSingle(@FOrdinal)^;
+                ftDouble: PDouble(@Result)^ := PDouble(@FOrdinal)^;
+            else
+                Result := IMyc3Value<T>( FManaged ).Value;
+            end;
+        end;
+
+        {$IFNDEF AUTOREFCOUNT}
+        tkClass,
+        {$ENDIF}
+        tkPointer:
+        begin
+            PPointer(@Result)^ := PPointer(@FOrdinal)^;
+        end;
+
+        tkInterface:
+        begin
+            IInterface(PPointer(@Result)^) := FManaged;
+        end;
+
+    else
+        begin
+            Result := IMyc3Value<T>( FManaged ).Value;
+        end;
+    end;
+end;
+
+{ TMycStateQueue }
+
+constructor TMycStateQueue.Create(const AStack: IAtomicStack<IMyc2State>);
+begin
+    FStack := AStack;
+end;
+
+procedure TMycStateQueue.Add(const S: IMyc2State);
+begin
+    FStack.Push( S );
+end;
+
+class function TMycStateQueue.Create: TMycStateQueue;
+begin
+    Result.Create( TAtomicStack<IMyc2State>.Create );
+end;
+
+procedure TMycStateQueue.WaitFor;
+var
+    S: IMyc2State;
+begin
+    S := FStack.Pop;
+    while S<>nil do
+    begin
+        Tasks.WaitFor( S );
+        S := FStack.Pop;
+    end;
+end;
+
+{ TMutable<T> }
+
+class function TMutable<T>.FromSignals(const Changed: array of IMyc2Signal; const Calculator: TFunc<T>): IMyc3Mutable<T>;
+begin
+    Result := TMyc3Mutable<T>.CreateMutable( Changed, Calculator );
+end;
+
+class function TMutable<T>.FromSignals(const Changed: array of IMyc2Signal; const Calculator: TFunc<IMyc3Mutable<T>>): IMyc3Mutable<T>;
+begin
+    Result := TMyc3EnclosedMutable<T>.Create( TMyc3Mutable<IMyc3Mutable<T>>.CreateMutable( Changed, Calculator ) );
+end;
+
+class function TMutable<T>.From<S>(const Value: IMyc3Mutable<S>; const Conv: TFunc<S, IMyc3Mutable<T>>): TMutable<T>;
+begin
+    Result := TMyc3EnclosedMutable<T>.Create( TValue<IMyc3Mutable<T>>.CreateMutable<S>( Value, Conv ) );
+end;
+
+class operator TMutable<T>.Explicit(const Value: T): TMutable<T>;
+begin
+    Result.FThis := TMyc3ConstantMutable<T>.Create( Value );
+end;
+
+class operator TMutable<T>.Implicit(
+  const Item: TMutable<T>): IMyc3Mutable<T>;
+begin
+    Result := Item.FThis;
+end;
+
+class operator TMutable<T>.Implicit(
+  const Item: IMyc3Mutable<T>): TMutable<T>;
+begin
+    Result.FThis := Item;
+end;
+
+{ TParameterValue }
+
+constructor TParameterValue.Create( ATypeInfo: PTypeInfo; const AMutable: IMyc3Mutable );
+begin
+    FMutable := AMutable;
+    {$ifdef DEBUG}
+    FTypeInfo := ATypeInfo;
+    {$endif}
+end;
+
+function TParameterValue.Get<T>: T;
+begin
+    Assert( FMutable<>nil, 'Value is NULL' );
+    Result := AsType<T>.Value;
+end;
+
+function TParameterValue.AsType<T>: IMyc3Mutable<T>;
+begin
+    {$ifdef DEBUG}
+    CheckType( TypeInfo( T ) );
+    {$endif}
+    Result := IMyc3Mutable<T>( FMutable );
+end;
+
+class function TParameterValue.Compare( const A, B: TParameterValue ): Integer;
+begin
+    Result := CompareValue( NativeInt( A.Mutable ), NativeInt( B.Mutable ) );
+end;
+
+class function TParameterValue.FromArray<T>( const Values: TArray<TParameterValue> ): TArray<IMyc3Mutable<T>>;
+var
+    i: Integer;
+begin
+    SetLength( Result, Length( Values ) );
+    for i := 0 to High( Result ) do
+        Result[i] := Values[i].AsType<T>;
+end;
+
+class function TParameterValue.Create<T>( const Intf: T ): TParameterValue;
+begin
+    Result.Create( TypeInfo( T ), TValue<T>.CreateMutable( Intf ) );
+end;
+
+class function TParameterValue.Create<T>( const Intf: IMyc3Mutable<T> ): TParameterValue;
+begin
+    Result.Create( TypeInfo( T ), Intf );
+end;
+
+constructor TParameterValue.Assign( const Src: TParameterValue );
+begin
+    {$ifdef DEBUG}
+    CheckType( Src.FTypeInfo );
+    {$endif}
+    FMutable := Src.FMutable;
+end;
+
+{$ifdef DEBUG}
+procedure TParameterValue.CheckType(TI: PTypeInfo);
+begin
+    Assert( FTypeInfo = TI, Format( 'Type mismatch (casting param %s to %s)', [FTypeInfo.Name, TI.Name] ) );
+end;
+{$endif}
+
+class function TParameterValue.FromVarRec( const VarRec: TVarRec ): TParameterValue;
+begin
+    case VarRec.VType of
+    vtInteger:
+        Result := TParameterValue.Create<Integer>( VarRec.VInteger );
+    vtBoolean:
+        Result := TParameterValue.Create<Boolean>( VarRec.VBoolean );
+    vtWideChar:
+        Result := TParameterValue.Create<WideChar>( VarRec.VWideChar );
+    vtInt64:
+        Result := TParameterValue.Create<Int64>( VarRec.VInt64^ );
+    vtChar:
+        Result := TParameterValue.Create<String>( String( VarRec.VChar ) );
+    vtPChar:
+        Result := TParameterValue.Create<String>( String( VarRec.VPChar ) );
+    vtPWideChar:
+        Result := TParameterValue.Create<String>( String( VarRec.VPWideChar ) );
+    vtString:
+        Result := TParameterValue.Create<String>( String( VarRec.VString^ ) );
+    vtWideString:
+        Result := TParameterValue.Create<String>( String( VarRec.VWideString ) );
+    vtAnsiString:
+        Result := TParameterValue.Create<String>( String( VarRec.VAnsiString ) );
+    vtUnicodeString:
+        Result := TParameterValue.Create<String>( String( VarRec.VUnicodeString ) );
+    vtObject:
+        Result := TParameterValue.Create<TObject>( TObject( VarRec.VObject ) );
+    vtClass:
+        Result := TParameterValue.Create<TClass>( VarRec.VClass );
+    vtVariant:
+        Result := TParameterValue.Create<Variant>( VarRec.VVariant^ );
+    vtPointer:
+        Result := TParameterValue.Create<Pointer>( VarRec.VPointer );
+    vtExtended:
+        Result := TParameterValue.Create<Extended>( VarRec.VExtended^ );
+    vtCurrency:
+        Result := TParameterValue.Create<Currency>( VarRec.VCurrency^ );
+    vtInterface:
+        Result := TParameterValue.Create<IInterface>( IInterface( VarRec.VInterface ) );
+    end;
+end;
+
+{ TParameterField }
+
+constructor TParameterField.Create( AID: TFieldID; const AValue: TParameterValue );
+begin
+    FID := AID;
+    FValue := AValue;
+end;
+
+class function TParameterField.Create<T>( ID: TFieldID; const Intf: IMyc3Mutable<T> ): TParameterField;
+begin
+    Result := TParameterField.Create( ID, TParameterValue.Create<T>( Intf ) );
+end;
+
+class function TParameterField.Create<T>( ID: TFieldID; const Intf: T ): TParameterField;
+begin
+    Result := TParameterField.Create( ID, TParameterValue.Create<T>( Intf ) );
+end;
+
+{ TParameterRecord }
+
+constructor TParameterRecord.Create( const AThis: IMyc3ParameterRecord );
+begin
+    FThis := AThis;
+end;
+
+function TParameterRecord.AsType<T>( ID: TFieldID ): IMyc3Mutable<T>;
+begin
+    Result := GetValues( ID ).AsType<T>;
+end;
+
+function TParameterRecord.Get<T>(ID: TFieldID): T;
+begin
+    Result := GetValues( ID ).Get<T>;
+end;
+
+function TParameterRecord.GetByName( const Caption: String ): TParameterValue;
+begin
+    Result := FThis.ByName[Caption];
+end;
+
+function TParameterRecord.GetDef: IMycParameterRecordDefinition;
+begin
+    Result := FThis.Def;
+end;
+
+function TParameterRecord.GetValues(ID: TFieldID): TParameterValue;
+begin
+    Result := FThis.Values[ID];
+end;
+
+class operator TParameterRecord.Implicit(const Item: IMyc3ParameterRecord): TParameterRecord;
+begin
+    Result.Create( Item );
+end;
+
+class operator TParameterRecord.Implicit(const Item: TParameterRecord): IMyc3ParameterRecord;
+begin
+    Result := Item.FThis;
+end;
+
+{ TParameterSpace }
+
+constructor TParameterSpace.Create( const AThis: IMycParameterSpace );
+begin
+    FThis := AThis;
+end;
+
+function TParameterSpace.CompareValues( FieldID: TFieldID; const A, B: TParameterValue ): Integer;
+begin
+    Result := FThis.CompareValues( FieldID, A, B );
+end;
+
+class function TParameterSpace.Create: TParameterSpace;
+begin
+    Result.Create( TMycParameterSpace.Create );
+end;
+
+function TParameterSpace.CreateRecord( const Fields: TArray<TParameterField> ): TParameterRecord;
+begin
+    Result.Create( FThis.CreateRecord( Fields ) );
+end;
+
+function TParameterSpace.GetCaptions( FieldID: TFieldID ): String;
+begin
+    Result := FThis.Captions[FieldID];
+end;
+
+function TParameterSpace.GetComparer( FieldID: TFieldID ): IComparer<TParameterValue>;
+begin
+    Result := FThis.Comparer[FieldID];
+end;
+
+function TParameterSpace.GetDefaultValues( FieldID: TFieldID ): TParameterValue;
+begin
+    Result := FThis.DefaultValues[FieldID];
+end;
+
+function TParameterSpace.GetFieldCount: Integer;
+begin
+    Result := FThis.FieldCount;
+end;
+
+function TParameterSpace.AddField<T>(const Caption: String; const DefaultValue: T; const Comparer: IComparer<T> = nil): TFieldID;
+var
+    ValueComparer: IComparer<T>;
+    Comp: IComparer<TParameterValue>;
+begin
+    ValueComparer := Comparer;
+    if ValueComparer=nil then
+        ValueComparer := TComparer<T>.Default;
+
+    Comp := TComparer<TParameterValue>.Construct(
+        function( const A, B: TParameterValue ): Integer
+        begin
+            if ( A.Mutable <> nil ) and ( B.Mutable<>nil ) then
+                Result := ValueComparer.Compare( A.AsType<T>.Value, B.AsType<T>.Value )
+            else if A.Mutable <> nil then
+                Result := 1
+            else if B.Mutable <> nil then
+                Result := -1
+            else
+                Result := 0;
+        end );
+
+    Result := FThis.AddField( TypeInfo( T ), Caption, TValue<T>.CreateMutable( DefaultValue ), Comp );
+end;
+
+function TParameterSpace.CreateDef(const Fields: TArray<TFieldID>): IMycParameterRecordDefinition;
+begin
+    Result := FThis.CreateDef( Fields );
+end;
+
+class operator TParameterSpace.Implicit( const Item: TParameterSpace ): IMycParameterSpace;
+begin
+    Result := Item.FThis;
+end;
+
+class operator TParameterSpace.Implicit( const Item: IMycParameterSpace ): TParameterSpace;
+begin
+    Result.Create( Item );
+end;
+
+{ TMutableFuture }
+
+class function TMutableFuture.FromArray<T>(const Value: TArray<IMyc3Mutable<IMyc3Future<T>>>): IMyc3Mutable<IMyc3Future<TArray<T>>>;
+begin
+    Result := Mutable.Convert<TArray<IMyc3Future<T>>, IMyc3Future<TArray<T>>>(
+        Mutable.FromArray<IMyc3Future<T>>( Value ),
+        function( Value: TArray<IMyc3Future<T>> ): IMyc3Future<TArray<T>>
+        begin
+            Result := TFuture.FromArray<T>( Value );
+        end );
+end;
+
+constructor TStackTrace.Create(ASkipFrames: Cardinal; const AMsg: String = '');
+begin
+    Msg := AMsg;
+    {$ifdef FullDebugMode}
+    FastMM_EnterDebugMode;
+    FastMM_GetStackTrace(@StackTrace, Length(StackTrace), 0);
+    {$endif}
+end;
+
+function TStackTrace.ToText: String;
+{$ifdef FullDebugMode}
+var
+    LStackTraceBuffer: array[0..Len * 160] of WideChar;
+{$endif}
+begin
+    Result := Msg;
+    if Result<>'' then
+        Result := Result + #13#10;
+
+    {$ifdef FullDebugMode}
+    FastMM_ConvertStackTraceToText(
+        @StackTrace, Length(StackTrace), @LStackTraceBuffer,
+        @LStackTraceBuffer[High(LStackTraceBuffer)]);
+
+    Result := Result + LStackTraceBuffer;
+    {$else}
+    Result := Result + 'StackTrace: FullDebugMode not enabled';
+    {$endif}
+end;
+
+class function TValidatable.FromSignal(const Signal: IMyc2Signal): IMyc3Validatable;
+begin
+    Result := TMyc3ValidatableSignal.Create(Signal);
+end;
+
+initialization
+
+Tasks := TMyc3Tasks.Create( TMyc2TaskFactory.Create );
+
+finalization
+
+FreeAndNil( Tasks );
+
+end.
diff --git a/Test/MycTests.dpr b/Test/MycTests.dpr
new file mode 100644
index 0000000..9fc7fdd
--- /dev/null
+++ b/Test/MycTests.dpr
@@ -0,0 +1,72 @@
+program MycTests;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}
+{$STRONGLINKTYPES ON}
+uses
+  FastMM5,
+  DUnitX.MemoryLeakMonitor.FastMM5,
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ELSE}
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  {$ENDIF }
+  DUnitX.TestFramework,
+  TestSignals in 'TestSignals.pas',
+  TestHeap in 'TestHeap.pas';
+
+{ keep comment here to protect the following conditional from being removed by the IDE when adding a unit }
+{$IFNDEF TESTINSIGHT}
+var
+  runner: ITestRunner;
+  results: IRunResults;
+  logger: ITestLogger;
+  nunitLogger : ITestLogger;
+{$ENDIF}
+begin
+{$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX.RunRegisteredTests;
+{$ELSE}
+  try
+    //Check command line options, will exit if invalid
+    TDUnitX.CheckCommandLine;
+    //Create the test runner
+    runner := TDUnitX.CreateRunner;
+    //Tell the runner to use RTTI to find Fixtures
+    runner.UseRTTI := True;
+    //When true, Assertions must be made during tests;
+    runner.FailsOnNoAsserts := False;
+
+    //tell the runner how we will log things
+    //Log to the console window if desired
+    if TDUnitX.Options.ConsoleMode <> TDunitXConsoleMode.Off then
+    begin
+      logger := TDUnitXConsoleLogger.Create(TDUnitX.Options.ConsoleMode = TDunitXConsoleMode.Quiet);
+      runner.AddLogger(logger);
+    end;
+    //Generate an NUnit compatible XML File
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile);
+    runner.AddLogger(nunitLogger);
+
+    //Run tests
+    results := runner.Execute;
+    if not results.AllPassed then
+      System.ExitCode := EXIT_ERRORS;
+
+    {$IFNDEF CI}
+    //We don't want this happening when running under CI.
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then
+    begin
+      System.Write('Done.. press <Enter> key to quit.');
+      System.Readln;
+    end;
+    {$ENDIF}
+  except
+    on E: Exception do
+      System.Writeln(E.ClassName, ': ', E.Message);
+  end;
+{$ENDIF}
+end.
diff --git a/Test/MycTests.dproj b/Test/MycTests.dproj
new file mode 100644
index 0000000..2bb4434
--- /dev/null
+++ b/Test/MycTests.dproj
@@ -0,0 +1,1121 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <PropertyGroup>
+        <ProjectGuid>{CE86C146-5191-415B-8DA3-35BE03E7C046}</ProjectGuid>
+        <ProjectVersion>20.3</ProjectVersion>
+        <FrameworkType>None</FrameworkType>
+        <Base>True</Base>
+        <Config Condition="'$(Config)'==''">Debug</Config>
+        <Platform Condition="'$(Platform)'==''">Win64</Platform>
+        <ProjectName Condition="'$(ProjectName)'==''">MycTests</ProjectName>
+        <TargetedPlatforms>3</TargetedPlatforms>
+        <AppType>Console</AppType>
+        <MainSource>MycTests.dpr</MainSource>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Base)'=='true') or '$(Base_Win32)'!=''">
+        <Base_Win32>true</Base_Win32>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win64' and '$(Base)'=='true') or '$(Base_Win64)'!=''">
+        <Base_Win64>true</Base_Win64>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_1)'!=''">
+        <Cfg_1>true</Cfg_1>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Cfg_1)'=='true') or '$(Cfg_1_Win32)'!=''">
+        <Cfg_1_Win32>true</Cfg_1_Win32>
+        <CfgParent>Cfg_1</CfgParent>
+        <Cfg_1>true</Cfg_1>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win64' and '$(Cfg_1)'=='true') or '$(Cfg_1_Win64)'!=''">
+        <Cfg_1_Win64>true</Cfg_1_Win64>
+        <CfgParent>Cfg_1</CfgParent>
+        <Cfg_1>true</Cfg_1>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_2)'!=''">
+        <Cfg_2>true</Cfg_2>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base)'!=''">
+        <DCC_DcuOutput>.\$(Platform)\$(Config)</DCC_DcuOutput>
+        <DCC_ExeOutput>.\$(Platform)\$(Config)</DCC_ExeOutput>
+        <DCC_E>false</DCC_E>
+        <DCC_N>false</DCC_N>
+        <DCC_S>false</DCC_S>
+        <DCC_F>false</DCC_F>
+        <DCC_K>false</DCC_K>
+        <DCC_Namespace>System;Xml;Data;Datasnap;Web;Soap;$(DCC_Namespace)</DCC_Namespace>
+        <UsingDelphiRTL>true</UsingDelphiRTL>
+        <Icon_MainIcon>$(BDS)\bin\delphi_PROJECTICON.ico</Icon_MainIcon>
+        <Icns_MainIcns>$(BDS)\bin\delphi_PROJECTICNS.icns</Icns_MainIcns>
+        <DCC_UnitSearchPath>$(DUnitX);..\Src;$(DCC_UnitSearchPath)</DCC_UnitSearchPath>
+        <SanitizedProjectName>MycTests</SanitizedProjectName>
+        <VerInfo_Locale>1031</VerInfo_Locale>
+        <VerInfo_Keys>CompanyName=;FileDescription=$(MSBuildProjectName);FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProgramID=com.embarcadero.$(MSBuildProjectName);ProductName=$(MSBuildProjectName);ProductVersion=1.0.0.0;Comments=</VerInfo_Keys>
+        <Debugger_RunParams>--exitbehavior:Pause</Debugger_RunParams>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base_Win32)'!=''">
+        <DCC_UsePackage>vclwinx;fmx;vclie;DbxCommonDriver;bindengine;IndyIPCommon;VCLRESTComponents;FireDACCommonODBC;FireDACCommonDriver;IndyProtocols;vclx;Skia.Package.RTL;IndyIPClient;dbxcds;vcledge;bindcompvclwinx;FmxTeeUI;bindcompfmx;inetdb;FireDACSqliteDriver;DbxClientDriver;Tee;soapmidas;vclactnband;TeeUI;fmxFireDAC;dbexpress;DBXMySQLDriver;VclSmp;inet;vcltouch;fmxase;dbrtl;Skia.Package.FMX;fmxdae;TeeDB;FireDACMSAccDriver;CustomIPTransport;vcldsnap;DBXInterBaseDriver;IndySystem;Skia.Package.VCL;vcldb;vclFireDAC;bindcomp;FireDACCommon;inetstn;IndyCore;RESTBackendComponents;bindcompdbx;rtl;FireDACMySQLDriver;FireDACADSDriver;RESTComponents;DBXSqliteDriver;vcl;IndyIPServer;dsnapxml;dsnapcon;adortl;vclimg;FireDACPgDriver;FireDAC;inetdbxpress;xmlrtl;tethering;bindcompvcl;dsnap;CloudService;fmxobj;bindcompvclsmp;FMXTee;soaprtl;soapserver;FireDACIBDriver;$(DCC_UsePackage)</DCC_UsePackage>
+        <DCC_Namespace>Winapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;$(DCC_Namespace)</DCC_Namespace>
+        <BT_BuildType>Debug</BT_BuildType>
+        <VerInfo_Keys>CompanyName=;FileDescription=$(MSBuildProjectName);FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProgramID=com.embarcadero.$(MSBuildProjectName);ProductName=$(MSBuildProjectName);ProductVersion=1.0.0.0;Comments=</VerInfo_Keys>
+        <VerInfo_Locale>1033</VerInfo_Locale>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base_Win64)'!=''">
+        <DCC_UsePackage>vclwinx;fmx;vclie;DbxCommonDriver;bindengine;IndyIPCommon;VCLRESTComponents;FireDACCommonODBC;FireDACCommonDriver;IndyProtocols;vclx;IndyIPClient;dbxcds;vcledge;bindcompvclwinx;FmxTeeUI;bindcompfmx;inetdb;FireDACSqliteDriver;DbxClientDriver;Tee;soapmidas;vclactnband;TeeUI;fmxFireDAC;dbexpress;DBXMySQLDriver;VclSmp;inet;vcltouch;fmxase;dbrtl;fmxdae;TeeDB;FireDACMSAccDriver;CustomIPTransport;vcldsnap;DBXInterBaseDriver;IndySystem;Skia.Package.VCL;vcldb;vclFireDAC;bindcomp;FireDACCommon;inetstn;IndyCore;RESTBackendComponents;bindcompdbx;rtl;FireDACMySQLDriver;FireDACADSDriver;RESTComponents;DBXSqliteDriver;vcl;IndyIPServer;dsnapxml;dsnapcon;adortl;vclimg;FireDACPgDriver;FireDAC;inetdbxpress;xmlrtl;tethering;bindcompvcl;dsnap;CloudService;fmxobj;bindcompvclsmp;FMXTee;soaprtl;soapserver;FireDACIBDriver;$(DCC_UsePackage)</DCC_UsePackage>
+        <DCC_Namespace>Winapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;$(DCC_Namespace)</DCC_Namespace>
+        <BT_BuildType>Debug</BT_BuildType>
+        <VerInfo_Locale>1033</VerInfo_Locale>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_1)'!=''">
+        <DCC_Define>DEBUG;$(DCC_Define)</DCC_Define>
+        <DCC_DebugDCUs>true</DCC_DebugDCUs>
+        <DCC_Optimize>false</DCC_Optimize>
+        <DCC_GenerateStackFrames>true</DCC_GenerateStackFrames>
+        <DCC_DebugInfoInExe>true</DCC_DebugInfoInExe>
+        <DCC_RemoteDebug>true</DCC_RemoteDebug>
+        <DCC_IntegerOverflowCheck>true</DCC_IntegerOverflowCheck>
+        <DCC_RangeChecking>true</DCC_RangeChecking>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_1_Win32)'!=''">
+        <DCC_RemoteDebug>false</DCC_RemoteDebug>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_1_Win64)'!=''">
+        <VerInfo_Locale>1033</VerInfo_Locale>
+        <Manifest_File>(None)</Manifest_File>
+        <AppDPIAwarenessMode>none</AppDPIAwarenessMode>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_2)'!=''">
+        <DCC_LocalDebugSymbols>false</DCC_LocalDebugSymbols>
+        <DCC_Define>RELEASE;$(DCC_Define)</DCC_Define>
+        <DCC_SymbolReferenceInfo>0</DCC_SymbolReferenceInfo>
+        <DCC_DebugInformation>0</DCC_DebugInformation>
+    </PropertyGroup>
+    <ItemGroup>
+        <DelphiCompile Include="$(MainSource)">
+            <MainSource>MainSource</MainSource>
+        </DelphiCompile>
+        <DCCReference Include="TestSignals.pas"/>
+        <DCCReference Include="TestHeap.pas"/>
+        <BuildConfiguration Include="Base">
+            <Key>Base</Key>
+        </BuildConfiguration>
+        <BuildConfiguration Include="Debug">
+            <Key>Cfg_1</Key>
+            <CfgParent>Base</CfgParent>
+        </BuildConfiguration>
+        <BuildConfiguration Include="Release">
+            <Key>Cfg_2</Key>
+            <CfgParent>Base</CfgParent>
+        </BuildConfiguration>
+    </ItemGroup>
+    <ProjectExtensions>
+        <Borland.Personality>Delphi.Personality.12</Borland.Personality>
+        <Borland.ProjectType>Application</Borland.ProjectType>
+        <BorlandProject>
+            <Delphi.Personality>
+                <Source>
+                    <Source Name="MainSource">MycTests.dpr</Source>
+                </Source>
+                <Excluded_Packages/>
+            </Delphi.Personality>
+            <Deployment Version="5">
+                <DeployFile LocalName="$(BDS)\Redist\iossimulator\libcgunwind.1.0.dylib" Class="DependencyModule">
+                    <Platform Name="iOSSimulator">
+                        <Overwrite>true</Overwrite>
+                    </Platform>
+                </DeployFile>
+                <DeployFile LocalName="$(BDS)\Redist\iossimulator\libpcre.dylib" Class="DependencyModule">
+                    <Platform Name="iOSSimulator">
+                        <Overwrite>true</Overwrite>
+                    </Platform>
+                </DeployFile>
+                <DeployFile LocalName="$(BDS)\Redist\osx32\libcgunwind.1.0.dylib" Class="DependencyModule">
+                    <Platform Name="OSX32">
+                        <Overwrite>true</Overwrite>
+                    </Platform>
+                </DeployFile>
+                <DeployFile LocalName="Win64\Debug\MycTests.exe" Configuration="Debug" Class="ProjectOutput">
+                    <Platform Name="Win64">
+                        <RemoteName>MycTests.exe</RemoteName>
+                        <Overwrite>true</Overwrite>
+                    </Platform>
+                </DeployFile>
+                <DeployFile LocalName="Win64\Debug\MycTests.rsm" Configuration="Debug" Class="DebugSymbols">
+                    <Platform Name="Win64">
+                        <RemoteName>MycTests.rsm</RemoteName>
+                        <Overwrite>true</Overwrite>
+                    </Platform>
+                </DeployFile>
+                <DeployClass Name="AdditionalDebugSymbols">
+                    <Platform Name="iOSSimulator">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Win32">
+                        <Operation>0</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidFileProvider">
+                    <Platform Name="Android">
+                        <RemoteDir>res\xml</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\xml</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidLibnativeArmeabiFile">
+                    <Platform Name="Android">
+                        <RemoteDir>library\lib\armeabi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>library\lib\armeabi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidLibnativeArmeabiv7aFile">
+                    <Platform Name="Android64">
+                        <RemoteDir>library\lib\armeabi-v7a</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidLibnativeMipsFile">
+                    <Platform Name="Android">
+                        <RemoteDir>library\lib\mips</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>library\lib\mips</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidServiceOutput">
+                    <Platform Name="Android">
+                        <RemoteDir>library\lib\armeabi-v7a</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>library\lib\arm64-v8a</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidServiceOutput_Android32">
+                    <Platform Name="Android64">
+                        <RemoteDir>library\lib\armeabi-v7a</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidSplashImageDef">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidSplashImageDefV21">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-anydpi-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-anydpi-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidSplashStyles">
+                    <Platform Name="Android">
+                        <RemoteDir>res\values</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\values</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidSplashStylesV21">
+                    <Platform Name="Android">
+                        <RemoteDir>res\values-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\values-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidSplashStylesV31">
+                    <Platform Name="Android">
+                        <RemoteDir>res\values-v31</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\values-v31</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="AndroidSplashStylesV35">
+                    <Platform Name="Android">
+                        <RemoteDir>res\values-v35</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\values-v35</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_AdaptiveIcon">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-anydpi-v26</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-anydpi-v26</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_AdaptiveIconBackground">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_AdaptiveIconForeground">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_AdaptiveIconMonochrome">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_AdaptiveIconV33">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-anydpi-v33</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-anydpi-v33</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_Colors">
+                    <Platform Name="Android">
+                        <RemoteDir>res\values</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\values</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_ColorsDark">
+                    <Platform Name="Android">
+                        <RemoteDir>res\values-night-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\values-night-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_DefaultAppIcon">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_LauncherIcon144">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-xxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-xxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_LauncherIcon192">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-xxxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-xxxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_LauncherIcon36">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-ldpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-ldpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_LauncherIcon48">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-mdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-mdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_LauncherIcon72">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-hdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-hdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_LauncherIcon96">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-xhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-xhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_NotificationIcon24">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-mdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-mdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_NotificationIcon36">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-hdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-hdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_NotificationIcon48">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-xhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-xhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_NotificationIcon72">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-xxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-xxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_NotificationIcon96">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-xxxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-xxxhdpi</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_SplashImage426">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-small</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-small</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_SplashImage470">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-normal</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-normal</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_SplashImage640">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-large</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-large</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_SplashImage960">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-xlarge</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-xlarge</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_Strings">
+                    <Platform Name="Android">
+                        <RemoteDir>res\values</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\values</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_VectorizedNotificationIcon">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-anydpi-v24</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-anydpi-v24</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_VectorizedSplash">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_VectorizedSplashDark">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-night-anydpi-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-night-anydpi-v21</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_VectorizedSplashV31">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-anydpi-v31</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-anydpi-v31</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="Android_VectorizedSplashV31Dark">
+                    <Platform Name="Android">
+                        <RemoteDir>res\drawable-night-anydpi-v31</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>res\drawable-night-anydpi-v31</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="DebugSymbols">
+                    <Platform Name="iOSSimulator">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Win32">
+                        <Operation>0</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="DependencyFramework">
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.framework</Extensions>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.framework</Extensions>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.framework</Extensions>
+                    </Platform>
+                    <Platform Name="Win32">
+                        <Operation>0</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="DependencyModule">
+                    <Platform Name="iOSDevice32">
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="Win32">
+                        <Operation>0</Operation>
+                        <Extensions>.dll;.bpl</Extensions>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Required="true" Name="DependencyPackage">
+                    <Platform Name="iOSDevice32">
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                        <Extensions>.dylib</Extensions>
+                    </Platform>
+                    <Platform Name="Win32">
+                        <Operation>0</Operation>
+                        <Extensions>.bpl</Extensions>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="File">
+                    <Platform Name="Android">
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice32">
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\Resources\StartUp\</RemoteDir>
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>Contents\Resources\StartUp\</RemoteDir>
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>Contents\Resources\StartUp\</RemoteDir>
+                        <Operation>0</Operation>
+                    </Platform>
+                    <Platform Name="Win32">
+                        <Operation>0</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectAndroidManifest">
+                    <Platform Name="Android">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectOSXDebug">
+                    <Platform Name="OSX64">
+                        <RemoteDir>..\$(PROJECTNAME).app.dSYM\Contents\Resources\DWARF</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>..\$(PROJECTNAME).app.dSYM\Contents\Resources\DWARF</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectOSXEntitlements">
+                    <Platform Name="OSX32">
+                        <RemoteDir>..\</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>..\</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>..\</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectOSXInfoPList">
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>Contents</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>Contents</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectOSXResource">
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\Resources</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>Contents\Resources</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>Contents\Resources</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Required="true" Name="ProjectOutput">
+                    <Platform Name="Android">
+                        <RemoteDir>library\lib\armeabi-v7a</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Android64">
+                        <RemoteDir>library\lib\arm64-v8a</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice32">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Linux64">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSX32">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSX64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="OSXARM64">
+                        <RemoteDir>Contents\MacOS</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Win32">
+                        <Operation>0</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectOutput_Android32">
+                    <Platform Name="Android64">
+                        <RemoteDir>library\lib\armeabi-v7a</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectUWPManifest">
+                    <Platform Name="Win32">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Win64">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Win64x">
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectiOSDeviceDebug">
+                    <Platform Name="iOSDevice32">
+                        <RemoteDir>..\$(PROJECTNAME).app.dSYM\Contents\Resources\DWARF</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).app.dSYM\Contents\Resources\DWARF</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).app.dSYM\Contents\Resources\DWARF</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectiOSEntitlements">
+                    <Platform Name="iOSDevice32">
+                        <RemoteDir>..\</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectiOSInfoPList">
+                    <Platform Name="iOSDevice32">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectiOSLaunchScreen">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen</RemoteDir>
+                        <Operation>64</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen</RemoteDir>
+                        <Operation>64</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="ProjectiOSResource">
+                    <Platform Name="iOSDevice32">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSDevice64">
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="UWP_DelphiLogo150">
+                    <Platform Name="Win32">
+                        <RemoteDir>Assets</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Win64">
+                        <RemoteDir>Assets</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="UWP_DelphiLogo44">
+                    <Platform Name="Win32">
+                        <RemoteDir>Assets</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="Win64">
+                        <RemoteDir>Assets</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iOS_AppStore1024">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPad_AppIcon152">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPad_AppIcon167">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPad_Launch2x">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPad_LaunchDark2x">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPad_Notification40">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPad_Setting58">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPad_SpotLight80">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_AppIcon120">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_AppIcon180">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Launch2x">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Launch3x">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_LaunchDark2x">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_LaunchDark3x">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\LaunchScreenImage.imageset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Notification40">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Notification60">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Setting58">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Setting87">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Spotlight120">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <DeployClass Name="iPhone_Spotlight80">
+                    <Platform Name="iOSDevice64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                    <Platform Name="iOSSimARM64">
+                        <RemoteDir>..\$(PROJECTNAME).launchscreen\Assets\AppIcon.appiconset</RemoteDir>
+                        <Operation>1</Operation>
+                    </Platform>
+                </DeployClass>
+                <ProjectRoot Platform="Android" Name="$(PROJECTNAME)"/>
+                <ProjectRoot Platform="Android64" Name="$(PROJECTNAME)"/>
+                <ProjectRoot Platform="iOSDevice32" Name="$(PROJECTNAME).app"/>
+                <ProjectRoot Platform="iOSDevice64" Name="$(PROJECTNAME).app"/>
+                <ProjectRoot Platform="iOSSimARM64" Name="$(PROJECTNAME).app"/>
+                <ProjectRoot Platform="Linux64" Name="$(PROJECTNAME)"/>
+                <ProjectRoot Platform="OSX32" Name="$(PROJECTNAME).app"/>
+                <ProjectRoot Platform="OSX64" Name="$(PROJECTNAME).app"/>
+                <ProjectRoot Platform="OSXARM64" Name="$(PROJECTNAME).app"/>
+                <ProjectRoot Platform="Win32" Name="$(PROJECTNAME)"/>
+                <ProjectRoot Platform="Win64" Name="$(PROJECTNAME)"/>
+                <ProjectRoot Platform="Win64x" Name="$(PROJECTNAME)"/>
+            </Deployment>
+            <Platforms>
+                <Platform value="Win32">True</Platform>
+                <Platform value="Win64">True</Platform>
+            </Platforms>
+        </BorlandProject>
+        <ProjectFileVersion>12</ProjectFileVersion>
+    </ProjectExtensions>
+    <Import Project="$(BDS)\Bin\CodeGear.Delphi.Targets" Condition="Exists('$(BDS)\Bin\CodeGear.Delphi.Targets')"/>
+    <Import Project="$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj" Condition="Exists('$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj')"/>
+    <Import Project="$(MSBuildProjectName).deployproj" Condition="Exists('$(MSBuildProjectName).deployproj')"/>
+</Project>
diff --git a/Test/MycTests.res b/Test/MycTests.res
new file mode 100644
index 0000000..333684a
Binary files /dev/null and b/Test/MycTests.res differ
diff --git a/Test/TestHeap.pas b/Test/TestHeap.pas
new file mode 100644
index 0000000..81654b7
--- /dev/null
+++ b/Test/TestHeap.pas
@@ -0,0 +1,436 @@
+unit TestHeap;
+
+interface
+
+uses
+  DUnitX.TestFramework,
+  Myc.Heap,         // The unit to be tested. TSListEntry and PSListEntry are expected from here.
+  System.SysUtils,  // For NativeUInt, FillChar, Format static class, etc.
+  System.SyncObjs,  // TInterlocked
+  Winapi.Windows,   // For general Windows API types if needed by Myc.Heap for TSListHeader.
+  System.Generics.Collections; // For TThreadedQueue<T>, TDictionary<K,V>
+
+type
+  // Test data structure for TSList items
+  PTestListItem = ^TTestListItem;
+  TTestListItem = record
+    ListEntry: TSListEntry; // Using TSListEntry from Myc.Heap.pas
+    ID: Integer;
+  end;
+
+  [TestFixture]
+  TMycTestHeap = class
+  private
+    const TestAlignmentMask = 15; // Corresponds to AlignmentBoundary = 16 in Myc.Heap.pas
+
+    // Helpers made static to be callable from anonymous threads
+    class function CreateTestListItem(ID: Integer): PTestListItem; static;
+    class procedure FreeTestListItem(var Item: PTestListItem); static;
+
+  public
+    [Setup]
+    procedure Setup;
+    [TearDown]
+    procedure TearDown;
+
+    // Alignment Stress Test
+    [Test]
+    procedure TestStressAlignmentAndDataIntegrity;
+
+    // --- TSList Single-Threaded Tests ---
+    [Test]
+    procedure TestTSList_CreateAndFree;
+    [Test]
+    procedure TestTSList_PushPopSingleEntry;
+    [Test]
+    procedure TestTSList_PushPopMultipleEntries_LIFO;
+    [Test]
+    procedure TestTSList_QueryDepth;
+    [Test]
+    procedure TestTSList_PopFromEmptyList;
+
+    // --- TSList Parallel Access Test ---
+    [Test]
+    [Timeout(30000)] // Timeout in milliseconds
+    procedure TestTSList_ParallelPushPop;
+
+    // Sample method (can be removed if not needed)
+    [Test]
+    procedure Test1;
+  end;
+
+implementation
+
+uses
+  System.Math,      // For Random and Randomize
+  System.Classes,   // For TThread
+  System.Types;     // For TWaitResult
+
+// --- Helper Implementations (static) ---
+
+class function TMycTestHeap.CreateTestListItem(ID: Integer): PTestListItem;
+begin
+  Myc.Heap.GetMemAligned(Result, SizeOf(TTestListItem));
+  Assert.IsNotNull(Result, Format('Failed to allocate memory for TestListItem ID %d', [ID]));
+  FillChar(Result^, SizeOf(TTestListItem), 0);
+  Result.ID := ID;
+end;
+
+class procedure TMycTestHeap.FreeTestListItem(var Item: PTestListItem);
+var
+  tempPtr: Pointer;
+begin
+  if Item <> nil then
+  begin
+    tempPtr := Item;
+    Myc.Heap.FreeMemAligned(tempPtr);
+    Item := nil;
+  end;
+end;
+
+// --- Fixture Setup/TearDown ---
+
+procedure TMycTestHeap.Setup;
+begin
+  Randomize;
+end;
+
+procedure TMycTestHeap.TearDown;
+begin
+end;
+
+// --- Alignment Stress Test Implementation ---
+
+procedure TMycTestHeap.TestStressAlignmentAndDataIntegrity;
+const
+  NumIterations = 300000;
+  MaxBlockSize = 1024 * 4;
+var
+  i: Integer;
+  sizeToAllocate: System.NativeUInt;
+  ptr: Pointer;
+  bytePtr: System.PByte; // Variable renamed from pByte
+  j: System.NativeUInt;
+  fillValue: Byte;
+  isNilAfterFreeExpected: Boolean;
+  originalPtrBeforeFree: Pointer;
+begin
+  for i := 1 to NumIterations do
+  begin
+    case i mod 10 of
+      0: sizeToAllocate := 1;
+      1: sizeToAllocate := TestAlignmentMask;
+      2: sizeToAllocate := TestAlignmentMask + 1;
+      3: sizeToAllocate := TestAlignmentMask + 2;
+      4: sizeToAllocate := 0;
+      5: sizeToAllocate := MaxBlockSize div 2;
+      6: sizeToAllocate := MaxBlockSize;
+      else
+        sizeToAllocate := System.NativeUInt(Random(MaxBlockSize -1) + 1);
+    end;
+
+    ptr := nil;
+    try
+      Myc.Heap.GetMemAligned(ptr, sizeToAllocate);
+      if sizeToAllocate = 0 then
+      begin
+        Assert.IsTrue(True, Format('Zero-size allocation processed (Iteration %d). Pointer: %p', [i, ptr]));
+      end
+      else if ptr = nil then
+      begin
+        Assert.Fail(Format('GetMemAligned returned nil for size %u (Iteration %d).',
+                     [sizeToAllocate, i]));
+      end
+      else
+      begin
+        Assert.AreEqual(System.NativeUInt(0), System.NativeUInt(ptr) and TestAlignmentMask,
+          Format('Pointer %p not 16-byte aligned. Size: %u, Iteration: %d. (Value AND Mask = %u)',
+                 [ptr, sizeToAllocate, i, System.NativeUInt(ptr) and TestAlignmentMask]));
+
+        fillValue := Byte(i mod 256);
+        System.FillChar(ptr^, sizeToAllocate, fillValue);
+
+        bytePtr := System.PByte(ptr);
+        for j := 0 to sizeToAllocate - 1 do
+        begin
+          if bytePtr[j] <> fillValue then
+          begin
+            Assert.Fail(Format('Data corruption at offset %u for pointer %p. Size: %u, Iteration: %d. Expected %u, got %u.',
+                         [j, ptr, sizeToAllocate, i, fillValue, bytePtr[j]]));
+            Break;
+          end;
+        end;
+      end;
+    finally
+      Myc.Heap.FreeMemAligned(ptr);
+    end;
+  end;
+end;
+
+// --- TSList Single-Threaded Test Implementations ---
+
+procedure TMycTestHeap.TestTSList_CreateAndFree;
+var
+  sListPtr: PSList;
+begin
+  sListPtr := TSList.Create;
+  Assert.IsNotNull(sListPtr, 'TSList.Create should return a non-nil pointer.');
+  Assert.AreEqual(0, sListPtr.QueryDepth, 'Newly created TSList should have a depth of 0.');
+  sListPtr.Free;
+end;
+
+procedure TMycTestHeap.TestTSList_PushPopSingleEntry;
+var
+  sListPtr: PSList;
+  item1: PTestListItem;
+  poppedInternalListEntry: PSListEntry;
+  poppedItem: PTestListItem;
+begin
+  sListPtr := TSList.Create;
+  Assert.IsNotNull(sListPtr);
+  item1 := TMycTestHeap.CreateTestListItem(101);
+  Assert.IsNotNull(item1);
+  sListPtr.Push(@item1.ListEntry);
+  Assert.AreEqual(1, sListPtr.QueryDepth, 'Depth should be 1 after one push.');
+  poppedInternalListEntry := sListPtr.Pop;
+  Assert.IsNotNull(poppedInternalListEntry, 'Pop should return the pushed item, not nil.');
+  poppedItem := PTestListItem(poppedInternalListEntry);
+  Assert.AreEqual(NativeUInt(item1), NativeUInt(poppedItem), 'Popped item should be the same as pushed item.');
+  Assert.AreEqual(item1.ID, poppedItem.ID, 'Popped item ID mismatch.');
+  Assert.AreEqual(0, sListPtr.QueryDepth, 'Depth should be 0 after popping the item.');
+  TMycTestHeap.FreeTestListItem(item1);
+  sListPtr.Free;
+end;
+
+procedure TMycTestHeap.TestTSList_PushPopMultipleEntries_LIFO;
+const
+  NumItems = 5;
+var
+  sListPtr: PSList;
+  items: array[1..NumItems] of PTestListItem;
+  poppedInternalListEntry: PSListEntry;
+  poppedItem: PTestListItem;
+  i: Integer;
+begin
+  sListPtr := TSList.Create;
+  Assert.IsNotNull(sListPtr);
+  for i := 1 to NumItems do
+  begin
+    items[i] := TMycTestHeap.CreateTestListItem(200 + i);
+    sListPtr.Push(@items[i].ListEntry);
+    Assert.AreEqual(i, sListPtr.QueryDepth, Format('Depth should be %d after %d pushes.', [i,i]));
+  end;
+  Assert.AreEqual(NumItems, sListPtr.QueryDepth, 'Final depth after all pushes incorrect.');
+  for i := NumItems downto 1 do
+  begin
+    poppedInternalListEntry := sListPtr.Pop;
+    Assert.IsNotNull(poppedInternalListEntry, Format('Pop should return an item, not nil (iteration %d).', [i]));
+    poppedItem := PTestListItem(poppedInternalListEntry);
+    Assert.AreEqual(NativeUInt(items[i]), NativeUInt(poppedItem),
+      Format('LIFO order violated. Expected item ID %d (original index %d), got ID %d.', [items[i].ID, i, poppedItem.ID]));
+    Assert.AreEqual(items[i].ID, poppedItem.ID, 'Popped item ID mismatch.');
+    Assert.AreEqual(i - 1, sListPtr.QueryDepth, Format('Depth incorrect after pop %d.', [NumItems - i + 1]));
+  end;
+  Assert.AreEqual(0, sListPtr.QueryDepth, 'Depth should be 0 after all items are popped.');
+  for i := 1 to NumItems do
+  begin
+    TMycTestHeap.FreeTestListItem(items[i]);
+  end;
+  sListPtr.Free;
+end;
+
+procedure TMycTestHeap.TestTSList_QueryDepth;
+var
+  sListPtr: PSList;
+  item1, item2: PTestListItem;
+begin
+  sListPtr := TSList.Create;
+  Assert.IsNotNull(sListPtr);
+  Assert.AreEqual(0, sListPtr.QueryDepth, 'Initial depth should be 0.');
+  item1 := TMycTestHeap.CreateTestListItem(301);
+  sListPtr.Push(@item1.ListEntry);
+  Assert.AreEqual(1, sListPtr.QueryDepth, 'Depth should be 1 after one push.');
+  item2 := TMycTestHeap.CreateTestListItem(302);
+  sListPtr.Push(@item2.ListEntry);
+  Assert.AreEqual(2, sListPtr.QueryDepth, 'Depth should be 2 after two pushes.');
+  sListPtr.Pop;
+  Assert.AreEqual(1, sListPtr.QueryDepth, 'Depth should be 1 after one pop.');
+  sListPtr.Pop;
+  Assert.AreEqual(0, sListPtr.QueryDepth, 'Depth should be 0 after two pops.');
+  TMycTestHeap.FreeTestListItem(item1);
+  TMycTestHeap.FreeTestListItem(item2);
+  sListPtr.Free;
+end;
+
+procedure TMycTestHeap.TestTSList_PopFromEmptyList;
+var
+  sListPtr: PSList;
+  poppedInternalListEntry: PSListEntry;
+begin
+  sListPtr := TSList.Create;
+  Assert.IsNotNull(sListPtr);
+  Assert.AreEqual(0, sListPtr.QueryDepth, 'Initial depth should be 0.');
+  poppedInternalListEntry := sListPtr.Pop;
+  Assert.IsNull(poppedInternalListEntry, 'Pop from an empty list should return nil.');
+  Assert.AreEqual(0, sListPtr.QueryDepth, 'Depth should still be 0 after pop from empty.');
+  sListPtr.Free;
+end;
+
+// --- TSList Parallel Access Test Implementation ---
+procedure TMycTestHeap.TestTSList_ParallelPushPop;
+const
+  NumThreads = 12;
+  OperationsPerThread = 50000;
+  QueueCapacityFactor = 2; // Factor to ensure log queues have enough space
+var
+  threads: array of TThread; // TThread from System.Classes
+  i: Integer;
+  sharedSList: PSList;
+  pushedIDs: TThreadedQueue<Integer>;
+  poppedIDs: TThreadedQueue<Integer>;
+  globalItemID: Integer;
+  pushedItemsFinal: TDictionary<Integer, Integer>;
+  currentPushedID: Integer; // Renamed from poppedItemValue for clarity in its context
+  currentPoppedID: Integer; // Renamed from poppedItemValue for clarity in its context
+  waitResult: TWaitResult;
+  remainingItem: PTestListItem;
+  remainingInternalEntry: PSListEntry;
+  logQueueCapacity: Integer;
+begin
+  sharedSList := TSList.Create;
+  Assert.IsNotNull(sharedSList, 'Failed to create shared TSList for parallel test.');
+
+  logQueueCapacity := NumThreads * OperationsPerThread * QueueCapacityFactor;
+  pushedIDs := TThreadedQueue<Integer>.Create(logQueueCapacity, INFINITE, 0); // PopTimeout = 0
+  poppedIDs := TThreadedQueue<Integer>.Create(logQueueCapacity, INFINITE, 0); // PopTimeout = 0
+  globalItemID := 0;
+
+  SetLength(threads, NumThreads);
+
+  for i := 0 to High(threads) do
+  begin
+    threads[i] := TThread.CreateAnonymousThread(
+      procedure
+      var
+        j: Integer;
+        item: PTestListItem;
+        poppedInternalEntry: PSListEntry;
+        itemID: Integer;
+        actionRand: Double;
+        pushLogResult: TWaitResult; // Renamed from pushResult for clarity
+      begin
+        for j := 1 to OperationsPerThread do
+        begin
+          actionRand := Random;
+          if actionRand < 0.5 then // Attempt to Push
+          begin
+            itemID := TInterlocked.Increment(globalItemID); // TInterlocked from System.SysUtils or System
+            item := TMycTestHeap.CreateTestListItem(itemID);
+            if item <> nil then
+            begin
+              sharedSList.Push(@item.ListEntry);
+              pushLogResult := pushedIDs.PushItem(itemID); // Use PushItem for TThreadedQueue
+              Assert.AreEqual(TWaitResult.wrSignaled, pushLogResult,
+                Format('Failed to push item ID %d to pushedIDs logging queue.', [itemID]));
+            end;
+          end
+          else // Attempt to Pop
+          begin
+            poppedInternalEntry := sharedSList.Pop;
+            if poppedInternalEntry <> nil then
+            begin
+              item := PTestListItem(poppedInternalEntry);
+              pushLogResult := poppedIDs.PushItem(item.ID); // Use PushItem for TThreadedQueue
+              Assert.AreEqual(TWaitResult.wrSignaled, pushLogResult,
+                Format('Failed to push item ID %d to poppedIDs logging queue.', [item.ID]));
+              TMycTestHeap.FreeTestListItem(item);
+            end;
+          end;
+          if j mod (OperationsPerThread div 10) = 0 then // Occasional sleep
+             TThread.Sleep(1); // TThread.Sleep from System.Classes
+        end;
+      end);
+      threads[i].FreeOnTerminate := false;
+  end;
+
+  for i := 0 to High(threads) do
+    threads[i].Start;
+
+  for i := 0 to High(threads) do
+  begin
+    threads[i].WaitFor;
+  end;
+
+  for i := 0 to High(threads) do
+    threads[i].Free;
+
+  while True do
+  begin
+    remainingInternalEntry := sharedSList.Pop;
+    if remainingInternalEntry = nil then Break;
+
+    remainingItem := PTestListItem(remainingInternalEntry);
+    waitResult := poppedIDs.PushItem(remainingItem.ID); // Use PushItem
+    Assert.AreEqual(TWaitResult.wrSignaled, waitResult,
+        Format('Failed to push remaining item ID %d to poppedIDs logging queue during drain.', [remainingItem.ID]));
+    TMycTestHeap.FreeTestListItem(remainingItem);
+  end;
+
+  Assert.AreEqual(0, sharedSList.QueryDepth, 'TSList should be empty after all operations and draining.');
+
+
+  Assert.AreEqual(pushedIDs.TotalItemsPushed, poppedIDs.TotalItemsPushed, // Compare total items PUSHED to each log queue
+    Format('Mismatch between total logged pushed items (%u) and total logged popped items (%u).',
+           [pushedIDs.TotalItemsPushed, poppedIDs.TotalItemsPushed]));
+
+  pushedItemsFinal := TDictionary<Integer, Integer>.Create;
+  try
+    // Drain pushedIDs queue using PopItem with timeout = 0 behavior
+    var qz: Integer;
+    while pushedIDs.PopItem(qz, currentPushedID) = TWaitResult.wrSignaled do
+    begin
+      if pushedItemsFinal.ContainsKey(currentPushedID) then
+        pushedItemsFinal.Items[currentPushedID] := pushedItemsFinal.Items[currentPushedID] + 1
+      else
+        pushedItemsFinal.Add(currentPushedID, 1);
+      if qz=0 then break;
+    end;
+
+    // Drain poppedIDs queue using PopItem with timeout = 0 behavior
+    while poppedIDs.PopItem(qz, currentPoppedID) = TWaitResult.wrSignaled do
+    begin
+      Assert.IsTrue(pushedItemsFinal.ContainsKey(currentPoppedID),
+        Format('Item ID %d was logged as popped but never logged as pushed.', [currentPoppedID]));
+      if pushedItemsFinal.ContainsKey(currentPoppedID) then // Re-check for safety before decrementing
+      begin
+          pushedItemsFinal.Items[currentPoppedID] := pushedItemsFinal.Items[currentPoppedID] - 1;
+      end;
+      if qz=0 then break;
+    end;
+
+    // Verify that all pushed items were accounted for (counts should be zero)
+    for currentPushedID in pushedItemsFinal.Keys do
+    begin
+      Assert.AreEqual(0, pushedItemsFinal.Items[currentPushedID],
+        Format('Item ID %d count mismatch. Final count in reconciliation dictionary is not zero (is %d).',
+               [currentPushedID, pushedItemsFinal.Items[currentPushedID]]));
+    end;
+  finally
+    pushedItemsFinal.Free;
+  end;
+
+  // Final cleanup
+  sharedSList.Free;
+  pushedIDs.Free;
+  poppedIDs.Free;
+end;
+
+// --- Existing Sample Test ---
+procedure TMycTestHeap.Test1;
+begin
+  // Example: Assert.IsTrue(True, 'Test1 passed');
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(TMycTestHeap);
+end.
diff --git a/Test/TestSignals.pas b/Test/TestSignals.pas
new file mode 100644
index 0000000..312bc9f
--- /dev/null
+++ b/Test/TestSignals.pas
@@ -0,0 +1,49 @@
+unit TestSignals;
+
+interface
+
+uses
+  DUnitX.TestFramework,
+  Myc.Atomic;
+
+type
+  [TestFixture]
+  TMycTest = class
+  public
+    [Setup]
+    procedure Setup;
+    [TearDown]
+    procedure TearDown;
+    // Sample Methods
+    // Simple single Test
+    [Test]
+    procedure Test1;
+    // Test with TestCase Attribute to supply parameters.
+    [Test]
+    [TestCase('TestA','1,2')]
+    [TestCase('TestB','3,4')]
+    procedure Test2(const AValue1 : Integer;const AValue2 : Integer);
+  end;
+
+implementation
+
+procedure TMycTest.Setup;
+begin
+end;
+
+procedure TMycTest.TearDown;
+begin
+end;
+
+procedure TMycTest.Test1;
+begin
+end;
+
+procedure TMycTest.Test2(const AValue1 : Integer;const AValue2 : Integer);
+begin
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(TMycTest);
+
+end.