From 08a110b02ff6e7a6fe2cd547b8f572b0f19f9099 Mon Sep 17 00:00:00 2001
From: Michael Schimmel <schimmel@mycelium.de>
Date: Sat, 24 May 2025 14:59:47 +0200
Subject: [PATCH] Heap Tests

---
 .gitignore           |   16 +-
 Src/Myc.Atomic.pas   |  108 ++
 Src/Myc.Heap.pas     |  144 ++
 Src/Myc.Signals.pas  | 1009 +++++++++++
 Src/Myc.pas          | 3848 ++++++++++++++++++++++++++++++++++++++++++
 Test/MycTests.dpr    |   72 +
 Test/MycTests.dproj  | 1121 ++++++++++++
 Test/MycTests.res    |  Bin 0 -> 152412 bytes
 Test/TestHeap.pas    |  436 +++++
 Test/TestSignals.pas |   49 +
 10 files changed, 6795 insertions(+), 8 deletions(-)
 create mode 100644 Src/Myc.Atomic.pas
 create mode 100644 Src/Myc.Heap.pas
 create mode 100644 Src/Myc.Signals.pas
 create mode 100644 Src/Myc.pas
 create mode 100644 Test/MycTests.dpr
 create mode 100644 Test/MycTests.dproj
 create mode 100644 Test/MycTests.res
 create mode 100644 Test/TestHeap.pas
 create mode 100644 Test/TestSignals.pas

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 0000000000000000000000000000000000000000..333684ad278e9b20d4042824f2f96e983b6e3a11
GIT binary patch
literal 152412
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

literal 0
HcmV?d00001

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.