x17lab: решил заняться исследованием алгоритмов и структур данных

///
/// MindBlow.hpp
///
 
#ifndef MINDBLOW_GUARD
#define MINDBLOW_GUARD
 
#include <initializer_list>
#include <iostream>
#include <sstream>
 
 
template<typename MindBlowStreamType>
class MindBlow
{
public:
 
    /// <summary>
    /// Shortcut for a data type.
    /// </summary>
    using x17labMindStreamerT         = MindBlowStreamType;
 
    /// <summary>
    /// Shortcut for a pointer.
    /// </summary>
    using x17labMindStreamerPtrT      = x17labMindStreamerT*;
 
    /// <summary>
    /// Shortcut for a size.
    /// </summary>
    using x17labMindStreamerSizeTT   = size_t;
 
    /// <summary>
    /// Other definitions.
    /// </summary>
    #define x17labInline             inline
    #define x17labNoThrow            noexcept
    #define x17labThrow              throw
    #define x17labNullptr            nullptr
 
    /// <summary>
    /// Dynamically allocated (raw) array.
    /// </summary>
    x17labMindStreamerPtrT          x17labMindStreamerRAWRWX;
 
    /// <summary>
    /// Count of items (track counter).
    /// </summary>
    x17labMindStreamerSizeTT        x17labMindStreamerSynchro;
 
    /// <summary>
    /// Newly dynamically allocated array class with 1 single item, and it's default value is 1.
    /// </summary>
    explicit
    x17labInline
    MindBlow()
    {
        x17labDekTheRaw(1u);
    }
 
    /// <summary>`
    /// Newly dynamically allocated array class with given amount of items.
    /// </summary>
    /// <param name="Synchro">Count of items to initialize items.</param>
    explicit
    x17labInline
    MindBlow(x17labMindStreamerSizeTT Synchro)
    {
        x17labDekTheRaw(Synchro);
    }
 
    /// <summary>
    /// Newly dynamically allocated array class with initializer list in it.
    /// </summary>
    /// <param name="SuperNovaIL">Initializer list.</param> 
    explicit
    x17labInline
    MindBlow(std::initializer_list<x17labMindStreamerT> SuperNovaIL)
    {
        x17labDekTheRaw(SuperNovaIL.size());
 
        if ((SuperNovaIL.size()) <= (0u))
        {
            x17labThrow (std::invalid_argument("MindBlow:: invalid argument has been passed."));
        }
 
        decltype(x17labMindStreamerSynchro) ILIterator {0u};
        for (x17labMindStreamerT Picker : SuperNovaIL)
        {
            x17labMindStreamerRAWRWX[ILIterator++] = Picker;
        }
    }
 
    /// <summary>
    /// Destructor (deallocate and free memory used by this dynamically allocated array class).
    /// </summary>
    x17labInline
    ~MindBlow()
    {
        x17labEjector();
        x17labNullify();
    }
 
    /// <summary>
    /// Get the amount of items in this dynamically allocated array class.
    /// </summary>
    /// <returns>Amount of items.</returns>
    x17labInline
    x17labMindStreamerSizeTT x17labMindStreamerSynchrohronizer()
    {
        if ((x17labNull()) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labMindStreamerSynchrohronizer:: x17lab is fully zeroed."));
        }
 
        return (x17labMindStreamerSynchro);
 
    }
 
    /// <summary>
    /// Check dynamically allocated array is out of bounds (internal check).
    /// </summary>
    /// <param name="Synchro">Index to check.</param> 
    /// <returns>True if its in range.</returns>
    x17labInline
    bool x17labOverflow(x17labMindStreamerSizeTT Synchro)
    {
        if ((Synchro) >= (x17labMindStreamerSynchro))
        {
            x17labThrow (std::invalid_argument("x17labOverflow:: overflow has been detected."));
        }
        
        return (true);
    }
 
    /// <summary>
    /// Create dynamically allocated aray class with given amount of items,  provided in argument.
    /// </summary>
    /// <param name="x17labSynchro">Tracker of items.</param> 
    x17labInline
    void x17labDekTheRaw(x17labMindStreamerSizeTT Synchro) x17labNoThrow
    {
        x17labMindStreamerRAWRWX  = new (x17labMindStreamerT[Synchro])();
        x17labMindStreamerSynchro =  {Synchro};
    }
 
    /// <summary>
    /// Check if there are items in this dynamically allocated array class.
    /// </summary>
    /// <returns>True in case allocated array class has items.</returns>
    x17labInline
    bool x17labNull() x17labNoThrow
    {
        if ((x17labMindStreamerSynchro) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labNull:: Synchro has been nulled."));
        }
 
        return (true);
    }
 
    /// <summary>
    /// Check if there is an initialiizer list in this dynamically allocated array class.
    /// </summary>
    /// <param name="SuperNovaIL">Initializer list to perform the needed checks.</param> 
    /// <returns>True in case has an initializer list.</returns>
    x17labInline
    bool x17labSuperNovaILOverflow(std::initializer_list<x17labMindStreamerT> SuperNovaIL)
    {
        if ((SuperNovaIL.size()) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labSuperNovaILOverflow:: argument is out of range."));
        }      
 
        return (true);
    }
 
    /// <summary>
    /// Check if proveded dynamically allocated array and it's index is valid.
    /// </summary>
    /// <param name="MindStreamRaw">Dynamically allcated (raw) array to check.</param> 
    /// <param name="Synchro">Index to perform the needed checks.</param> 
    /// <returns>True in case array within the range.</returns>
    x17labInline
    bool x17labFlow(x17labMindStreamerPtrT MindStreamRaw, x17labMindStreamerSizeTT Synchro)
    {
        if ((MindStreamRaw) == (x17labNullptr) || (Synchro) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labFlow:: error has been detected."));
        }
 
        return (false);
    }
 
    /// <summary>
    /// Check if dynamically allocated array class has items in it.
    /// </summary> 
    /// <returns>True in case has items.</returns>
    x17labInline
    bool x17labIsAvailable() x17labNoThrow
    {
        if ((x17labMindStreamerSynchro) <= (0u))
        {
            x17labThrow (std::invalid_argument("x17labIsAvailable:: array has not items in it."));
        }
 
        return (true);
    }
 
    /// <summary>
    /// Assign item for this dynamically allocated array class to a provided one.
    /// </summary>
    /// <param name="StreamerValue">Value to set.</param>
    /// <param name="Synchro">Index to set.</param> 
    x17labInline
    void x17labYield(x17labMindStreamerT StreamerValue, x17labMindStreamerSizeTT Synchro)
    {
        if (x17labOverflow(Synchro))
        {
            x17labThrow (std::invalid_argument("x17labYield:: invalid argument."));
        }
 
        x17labMindStreamerRAWRWX[Synchro] = {StreamerValue};
    }
 
    /// <summary>
    /// Assign this dynamocally allocated array class to another array (raw).
    /// </summary>
    /// <param name="MindStreamerPtr">Raw array."</param>
    x17labInline
    void x17labYield(x17labMindStreamerPtrT MindStreamerPtr)
    {   
        if (x17labMindStreamerRAWRWX    == (x17labNullptr) ||
            MindStreamerPtr             == (x17labNullptr))
        {
            x17labThrow(std::invalid_argument("x17labYield:: invalid array."));
        }
 
        x17labMindStreamerRAWRWX = MindStreamerPtr;
    }
 
    // <summary>
    // Change the size of this dynamically allocated array class (raw array).
    // Allocate new buffer, and assign the new buffer to a raw array. 
    // </summary>
    // <param name="New">New size."</param>
    x17labInline
    void x17labShrinkify(x17labMindStreamerSizeTT New) x17labNoThrow
    {
        x17labMindStreamerPtrT MindStreamPtrNew = new x17labMindStreamerT[New]();
        if (MindStreamPtrNew != (x17labNullptr))
        {
            std::memcpy((MindStreamPtrNew), x17labMindStreamerRAWRWX, (x17labMindStreamerSynchro * sizeof(x17labMindStreamerT)));
            if (MindStreamPtrNew != (x17labNullptr))
            {
                x17labMindStreamerSynchro = New;
            }
        }
 
        x17labYield(MindStreamPtrNew);
 
        x17labEjector(MindStreamPtrNew);
        x17labNullify(MindStreamPtrNew);
    }
 
    /// <summary>
    /// Finds the summaty of all items in this dynamically allocated array class.
    /// </summary> 
    /// <returns>Summary of elements.</returns>
    x17labInline
    x17labMindStreamerSizeTT x17labSeekSummary() x17labNoThrow
    {
        x17labMindStreamerSizeTT Summary = {0u};
        for (x17labMindStreamerT (Picker) : x17labMindStreamerRAWRWX)
        {
            (Summary += (Picker));
        }
 
        return (Summary);
    }
 
    /// <summary>
    /// Check if this dynamically allocated array class is valid.
    /// </summary>
    /// <returns>True in case array is valid.</returns>
    x17labInline
    bool x17labIntegrity() x17labNoThrow
    {
        if (x17labMindStreamerRAWRWX != x17labNullptr)
        {
            x17labThrow(std::invalid_argument("x17labIntegrity:: invalid intergity."));
        }
 
        return (false);
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array using delete[] operator (internal).
    /// </summary>
    x17labInline
    void x17labEjector() x17labNoThrow
    {
        if (x17labMindStreamerRAWRWX != (x17labNullptr))
        {
            delete [] x17labMindStreamerRAWRWX;
        }
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array using delete[] operator.
    /// </summary>
    x17labInline
    void x17labEjector(x17labMindStreamerPtrT MindStreamerPtr) x17labNoThrow
    {
        if (MindStreamerPtr != (x17labNullptr))
        {
            delete [] MindStreamerPtr;
        }
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array class (internal). 
    /// </summary>
    x17labInline
    void x17labNullify() x17labNoThrow
    {
        x17labMindStreamerRAWRWX = (x17labNullptr);
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array class. 
    /// </summary>
    /// <param name="MindStreamerPtr">Raw."</param>
    x17labInline
    void x17labNullify(x17labMindStreamerPtrT MindStreamerPtr) x17labNoThrow
    {
        MindStreamerPtr = (x17labNullptr);
    }
 
    /// <summary>
    /// Print content by using console.
    /// </summary>
    x17labInline
    void x17labStringlyfi() x17labNoThrow
    {
        std::wstringstream WStreamStringlyfi{};
        for (decltype(x17labMindStreamerSynchro) SynchroIt{ 0u }; SynchroIt < x17labMindStreamerSynchro; SynchroIt++)
        {
            WStreamStringlyfi << "StreamerIdx: " << SynchroIt << " Value: " << x17labMindStreamerRAWRWX[SynchroIt] << " " << std::endl;
        }
 
        std::wcout << WStreamStringlyfi.str() << std::endl;
    }
};
 
#endif

///
/// MindFlareRAWRWX.hpp
///
 
#ifndef MINDFLARERAWRWX_GUARD
#define MINDFLARERAWRWX_GUARD
 
#include <initializer_list>
#include <iostream>
#include <sstream>
 
 
template<typename MindFlareRAWRWXType>
class MindFlareRAWRWX
{
public:
 
    /// <summary>
    /// DataT (link).
    /// <summary>
    using x17labMindFlareRAWRWXPointerT     = MindFlareRAWRWXType;
 
    /// <summary>
    /// Raw pointer (link).
    /// </summary>
    using x17labMindFlareRAWRWXStarT        = x17labMindFlareRAWRWXPointerT*;
 
    /// <summary>
    /// Size (link).
    /// </summary>
    using MindFlareRAWRWXSizetT             = size_t;
 
    /// <summary>
    /// Inline function.
    /// </summary>
    #define x17labMindFlareRAWRWXInline     inline
 
    /// <summary>
    /// Noexcept definition. 
    /// </summary>
    #define x17labRAWRWXX17CitadelOfDeath   noexcept
 
    /// <summary>
    /// Throw exception.
    /// </summary>
    #define x17labMindFlareRAWRWXThrow      throw
 
    /// <summary>
    /// Void ponter.
    /// </summary>
    #define x17labRAWRAWRWXNullReference    nullptr
 
    /// <summary>
    /// Constant expression.
    /// </summary>
    #define x17labMindFlareRAWRWXConst      const
 
    /// <summary>
    /// Dynamically allocated (raw) array.
    /// </summary>
    x17labMindFlareRAWRWXStarT              x17labMindFlareRAWRWXPointer;
 
    /// <summary>
    /// Count of items (track counter).
    /// </summary>
    MindFlareRAWRWXSizetT                   x17labMindFlareRAWRWXSynchrofazathron;
 
    /// <summary>
    /// Newly dynamically allocated array class with 1 single item, and it's default value is 1.
    /// </summary>
    explicit
    x17labMindFlareRAWRWXInline
    MindFlareRAWRWX()
    {x17labDekTheRawInternal(1u);}
 
    /// <summary>`
    /// Newly dynamically allocated array class with given amount of items.
    /// </summary>
    /// <param name="Synchrofazathron">Count of items to initialize.</param>
    explicit
    x17labMindFlareRAWRWXInline
    MindFlareRAWRWX(MindFlareRAWRWXSizetT Synchrofazathron)
    {x17labDekTheRawInternal(Synchrofazathron);}
 
    /// <summary>
    /// Newly dynamically allocated array class with initializer list in it.
    /// </summary>
    /// <param name="NovaIL">Initializer list.</param> 
    explicit
    x17labMindFlareRAWRWXInline
    MindFlareRAWRWX(std::initializer_list<x17labMindFlareRAWRWXPointerT> NovaIL)
    {
        x17labDekTheRawInternal(NovaIL.size());
 
        if ((NovaIL.size()) <= (0))
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("MindFlareRAWRWX:: invalid argument has been passed."));}
 
        decltype(x17labMindFlareRAWRWXSynchrofazathron) RAWRWXILIterator {0u};
        for (x17labMindFlareRAWRWXPointerT(RAWRWXPicker) : (NovaIL))
        {
            x17labMindFlareRAWRWXPointer[RAWRWXILIterator] = (RAWRWXPicker);
            RAWRWXILIterator++;
        }
    }
 
    /// <summary>
    /// Destructor (deallocate and free memory used by this dynamically allocated array class).
    /// </summary>
    x17labMindFlareRAWRWXInline
    ~MindFlareRAWRWX()
    {
        x17labEjectorInternal();
        x17labNullifyInternal();
    }
 
    /// <summary>
    /// <<Get the amount of items in this dynamically allocated array class.>>
    /// </summary>
    /// <returns>Amount of items.</returns>
    x17labMindFlareRAWRWXInline
    MindFlareRAWRWXSizetT x17labMindFlareRAWRWXSynchofazathronG()
    {
        if ((x17labNull()) <= (0u))
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("x17lab is fully zeroed."));}
 
        return (x17labMindFlareRAWRWXSynchrofazathron);
 
    }
 
    /// <summary>
    /// Check dynamically allocated array is out of bounds (internal check).
    /// </summary>
    /// <param name="Synchro">Index to check.</param> 
    /// <returns>True if its in range.</returns>
    x17labMindFlareRAWRWXInline
    bool x17labOutOfRange(MindFlareRAWRWXSizetT Synchrofazathron)
    {
        if ((Synchrofazathron) >= (x17labMindFlareRAWRWXSynchrofazathron))
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labOutOfRange:: overflow has been detected."));}
 
        return (true);
    }
 
    /// <summary>
    /// Create dynamically allocated aray class with given amount of items, provided in argument.
    /// </summary>
    /// <param name="Synchrofazathron">Tracker of items.</param>
    /// <returns>Pointer to an array.</returns>
    x17labMindFlareRAWRWXInline
    void x17labDekTheRaw(MindFlareRAWRWXSizetT Synchrofazathron) x17labRAWRWXX17CitadelOfDeath
    {
        x17labMindFlareRAWRWXConst x17labMindFlareRAWRWXStarT RAWRWXPointer = new (x17labMindFlareRAWRWXPointerT[Synchrofazathron])();
        return (RAWRWXPointer);
    }
 
    /// <summary>
    /// Create dynamically allocated aray class with given amount of items,  provided in argument.
    /// </summary>
    /// <param name="Synchrofazathron">Tracker of items.</param> 
    x17labMindFlareRAWRWXInline
    void x17labDekTheRawInternal(MindFlareRAWRWXSizetT Synchrofazathron) x17labRAWRWXX17CitadelOfDeath
    {
        x17labMindFlareRAWRWXPointer           = new (x17labMindFlareRAWRWXPointerT[Synchrofazathron])();
        x17labMindFlareRAWRWXSynchrofazathron  = {Synchrofazathron};
    }
 
    /// <summary>
    /// Check if there are items in this dynamically allocated array class.
    /// </summary>
    /// <returns>True in case allocated array class has items.</returns>
    x17labMindFlareRAWRWXInline
    bool x17labNull() x17labRAWRWXX17CitadelOfDeath
    {
        if ((x17labMindFlareRAWRWXSynchrofazathron) <= (0))
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labNull:: Synchrofazathron has been nulled."));}
 
        return (true);
    }
 
    /// <summary>
    /// Check if there is an initialiizer list in this dynamically allocated array class.
    /// </summary>
    /// <param name="NovaIL">Initializer list to perform the needed checks.</param> 
    /// <returns>True in case has an initializer list.</returns>
    x17labMindFlareRAWRWXInline
    bool x17labSuperNovaILOverflow(std::initializer_list<x17labMindFlareRAWRWXPointerT> NovaIL)
    {
        if ((NovaIL.size()) <= (0))
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labSuperNovaILOverflow:: argument is out of range."));}
 
        return (true);
    }
 
    /// <summary>
    /// Check if proveded dynamically allocated array and it's index is valid.
    /// </summary>
    /// <param name="RAWRWXPointer">Dynamically allcated (raw) array to check.</param> 
    /// <param name="Synchrofazathron">Index to perform the needed checks.</param> 
    /// <returns>True in case array within the range.</returns>
    x17labMindFlareRAWRWXInline
    bool x17labRAWRWXFlow(x17labMindFlareRAWRWXConst x17labMindFlareRAWRWXStarT RAWRWXPointer, MindFlareRAWRWXSizetT Synchrofazathron) x17labMindFlareRAWRWXConst
    {
        if ((RAWRWXPointer)    == (x17labRAWRAWRWXNullReference) ||
            (Synchrofazathron) <= (0))
        {
            x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labFlow:: error has been detected."));
        }
 
        return (false);
    }
 
    /// <summary>
    /// Check if dynamically allocated array class has items in it.
    /// </summary> 
    /// <returns>True in case has items.</returns>
    x17labMindFlareRAWRWXInline
    bool x17labIsAvailable() x17labRAWRWXX17CitadelOfDeath
    {
        if ((x17labMindFlareRAWRWXSynchrofazathron) <= (0u))
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labIsAvailable:: array has not items in it."));}
 
        return (true);
    }
 
    /// <summary>
    /// Assign item for this dynamically allocated array class to a provided one.
    /// </summary>
    /// <param name="RAWRWXValue">Value to set (index to set).</param>
    /// <param name="Synchrofazathron">Index to set.</param> 
    x17labMindFlareRAWRWXInline
    void x17labYield(x17labMindFlareRAWRWXPointerT RAWRWXValue, MindFlareRAWRWXSizetT Synchrofazathron) x17labMindFlareRAWRWXConst
    {
        if (x17labOutOfRange(Synchrofazathron))
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labYield:: invalid argument."));}
 
        x17labMindFlareRAWRWXPointer[Synchrofazathron] = { RAWRWXValue };
    }
 
    /// <summary>
    /// Assign this dynamocally allocated array class to another array (raw).
    /// </summary>
    /// <param name="RAWRWXPointer">Raw array."</param>
    x17labMindFlareRAWRWXInline
    void x17labYield(x17labMindFlareRAWRWXStarT RAWRWXPointer) x17labMindFlareRAWRWXConst
    {
        if (x17labMindFlareRAWRWXPointer == (x17labRAWRAWRWXNullReference) ||
            RAWRWXPointer                == (x17labRAWRAWRWXNullReference))
        {
            x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labYield:: invalid array."));
        }
 
        x17labMindFlareRAWRWXPointer = {RAWRWXPointer};
    }
 
    /// <summary>
    /// Change the size of this dynamically allocated array class (raw array).
    /// Allocate new buffer, and assign the new buffer to a raw array.
    /// </summary>
    /// <param name="RAWRWXNew">New size."</param>
    x17labMindFlareRAWRWXInline
    void X17LabSlim(MindFlareRAWRWXSizetT RAWRWXNew) x17labRAWRWXX17CitadelOfDeath
    {
        x17labMindFlareRAWRWXStarT RAWRWXPointer = new x17labMindFlareRAWRWXPointerT[RAWRWXNew]();
        if (RAWRWXPointer != (x17labRAWRAWRWXNullReference))
        {
            x17labCopy((RAWRWXPointer), x17labMindFlareRAWRWXPointer, (x17labMindFlareRAWRWXSynchrofazathron * sizeof(x17labMindFlareRAWRWXPointerT)));
            if (RAWRWXPointer != (x17labRAWRAWRWXNullReference))
            {
                x17labMindFlareRAWRWXSynchrofazathron = (RAWRWXNew);
            }
        }
 
        x17labYield(RAWRWXPointer);
 
        x17labEjector(RAWRWXPointer);
        x17labNullify(RAWRWXPointer);
    }
 
    /// <summary>
    /// Change the size of this dynamically allocated array class (raw array), and fill it with required data.
    /// </summary>
    /// <param name="RAWRWXNew">New size to change."</param>
    /// <param name="RAWRWXValue">Value to fill."</param>
    x17labMindFlareRAWRWXInline
    void x17labShrinkifyAll(MindFlareRAWRWXSizetT RAWRWXNew, x17labMindFlareRAWRWXPointerT RAWRWXValue) x17labRAWRWXX17CitadelOfDeath
    {
        X17LabSlim(RAWRWXNew);
        if (RAWRWXNew > 0u)
        {
            x17labInfuse(x17labMindFlareRAWRWXPointer, (x17labMindFlareRAWRWXPointer)+(x17labMindFlareRAWRWXSynchrofazathron), RAWRWXValue);
        }
    }
 
    /// <summary>
    /// Finds the summaty of all items in this dynamically allocated array class.
    /// </summary> 
    /// <returns>Summary of elements.</returns>
    x17labMindFlareRAWRWXInline
    MindFlareRAWRWXSizetT x17labSummary() x17labRAWRWXX17CitadelOfDeath
    {
        MindFlareRAWRWXSizetT RAWRWXSummary = {0u};
        for (x17labMindFlareRAWRWXPointerT(RAWRWXPicker) : x17labMindFlareRAWRWXPointer)
        {(RAWRWXSummary += (RAWRWXPicker));}
 
        return (RAWRWXSummary);
    }
 
    /// <summary>
    /// Finds the maximal value if this dynamically allocated array class.
    /// </summary> 
    /// <returns>Maximal item.</returns>
    x17labMindFlareRAWRWXInline
    MindFlareRAWRWXSizetT x17labFindMax() x17labRAWRWXX17CitadelOfDeath
    {
        MindFlareRAWRWXSizetT RAWRWXMaximal = {0u};
 
        for (decltype(x17labMindFlareRAWRWXSynchrofazathron) RAWRWXQueryMaximalIterator = {0u}; (RAWRWXQueryMaximalIterator) <
            (x17labMindFlareRAWRWXSynchrofazathron);
            RAWRWXQueryMaximalIterator++)
        {
            if (x17labMindFlareRAWRWXPointer[RAWRWXQueryMaximalIterator] > RAWRWXMaximal)
            {RAWRWXMaximal = (x17labMindFlareRAWRWXPointer[RAWRWXQueryMaximalIterator]);}
        }
 
        return (RAWRWXMaximal);
    }
 
    /// <summary>
    /// Append item in a dynamically allocated array class.
    /// </summary>
    /// <param name="RAWRWXValue">Value to append."</param>
    x17labMindFlareRAWRWXInline
    void x17labAppend(x17labMindFlareRAWRWXPointerT RAWRWXValue) x17labRAWRWXX17CitadelOfDeath
    {
        X17LabSlim(x17labMindFlareRAWRWXSynchrofazathron + (1u));
        x17labMindFlareRAWRWXPointer[x17labMindFlareRAWRWXSynchrofazathron + 1u] = (RAWRWXValue);
    }
 
    /// <summary>
    /// Append class instance in a dynamically allocated array class.
    /// </summary>
    /// <param name="RAWRWXClass">Class to add."</param>
    x17labMindFlareRAWRWXInline
    void x17labAppendClass(MindFlareRAWRWX<x17labMindFlareRAWRWXPointerT> RAWRWXClass) x17labRAWRWXX17CitadelOfDeath
    {
        for (decltype(x17labMindFlareRAWRWXSynchrofazathron) RAWRWXClassIterator = {0u};
            (RAWRWXClassIterator) < (x17labMindFlareRAWRWXSynchrofazathron);
             RAWRWXClassIterator++)
        {
            x17labMindFlareRAWRWXStarT[RAWRWXClassIterator] = (RAWRWXClass.x17labMindFlareRAWRWXPointer[RAWRWXClassIterator]);
        }
    }
 
    /// <summary>
    /// Finds the exact value in this dynamically allocated array class.
    /// </summary> 
    /// <param name="RAWRWXQuery">Query value."</param>
    /// <returns>True in case has an item.</returns>
    x17labMindFlareRAWRWXInline
    bool x17labQuery(x17labMindFlareRAWRWXPointerT RAWRWXQuery) x17labRAWRWXX17CitadelOfDeath
    {
        for (decltype(x17labMindFlareRAWRWXSynchrofazathron) (RAWRWXQueryIterator) = {0u};
            (RAWRWXQueryIterator) < (x17labMindFlareRAWRWXSynchrofazathron);
             RAWRWXQueryIterator++)
        {
            if (x17labMindFlareRAWRWXPointer[RAWRWXQueryIterator] == (RAWRWXQuery))
            {return (true);}
        }
 
        return (false);
    }
 
    /// <summary>
    /// Get the first element in this dynamically allocate array class.
    /// </summary> 
    /// <returns>First element in the array.</returns>
    x17labMindFlareRAWRWXInline
    x17labMindFlareRAWRWXPointerT WPickerFirst() x17labRAWRWXX17CitadelOfDeath
    {return (x17labMindFlareRAWRWXPointer[0u]);}
 
    /// <summary>
    /// Get the last element in this dynamically allocate array class.
    /// </summary> 
    /// <returns>Last element in the array.</returns>
    x17labMindFlareRAWRWXInline
    x17labMindFlareRAWRWXPointerT WPickerLast() x17labRAWRWXX17CitadelOfDeath
    {return (x17labMindFlareRAWRWXPointer[x17labMindFlareRAWRWXSynchrofazathron]);}
 
    /// <summary>
    /// Check if this dynamically allocated array class is valid.
    /// </summary>
    /// <returns>True in case array is valid.</returns>
    x17labMindFlareRAWRWXInline
    bool x17labIntegrity() x17labRAWRWXX17CitadelOfDeath
    {
        if (x17labMindFlareRAWRWXPointer != x17labRAWRAWRWXNullReference)
        {x17labMindFlareRAWRWXThrow(std::invalid_argument("x17labIntegrity:: invalid integrity."));}
 
        return (false);
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array using delete[] operator (internal routine).
    /// </summary>
    x17labMindFlareRAWRWXInline
    void x17labEjectorInternal() x17labRAWRWXX17CitadelOfDeath
    {
        if (x17labMindFlareRAWRWXPointer != (x17labRAWRAWRWXNullReference))
        {delete [] x17labMindFlareRAWRWXPointer;}
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array using delete[] operator.
    /// </summary>
    x17labMindFlareRAWRWXInline
    void x17labEjector(x17labMindFlareRAWRWXStarT RAWRWXPointer) x17labRAWRWXX17CitadelOfDeath
    {
        if (RAWRWXPointer != (x17labRAWRAWRWXNullReference))
        {delete [] RAWRWXPointer;}
    }
 
    /// <summary>
    /// Destroy the dynamically allacated array class (internal routine).
    /// </summary>
    x17labMindFlareRAWRWXInline
    void x17labNullifyInternal() x17labRAWRWXX17CitadelOfDeath
    {x17labMindFlareRAWRWXPointer = (x17labRAWRAWRWXNullReference);}
 
    /// <summary>
    /// Destroy the dynamically allacated array class.
    /// </summary>
    /// <param name="MindFlareRAWRWXP">Raw array."</param>
    x17labMindFlareRAWRWXInline
    void x17labNullify(x17labMindFlareRAWRWXStarT RAWRWXPointer) x17labRAWRWXX17CitadelOfDeath
    {RAWRWXPointer = (x17labRAWRAWRWXNullReference);}
 
    /// <summary>
    /// Print content by using console.
    /// </summary>
    x17labMindFlareRAWRWXInline
    void x17labStringlyfi() x17labRAWRWXX17CitadelOfDeath
    {
        std::wstringstream WStreamStringlyfi {};
        for (decltype(x17labMindFlareRAWRWXSynchrofazathron) RAWRWXSynchronizerIterator {0u};
            RAWRWXSynchronizerIterator < x17labMindFlareRAWRWXSynchrofazathron;
            RAWRWXSynchronizerIterator++)
        {WStreamStringlyfi << "Idx: " << RAWRWXSynchronizerIterator << " Value: " << x17labMindFlareRAWRWXPointer[RAWRWXSynchronizerIterator] << " " << std::endl;}
 
        std::wcout << WStreamStringlyfi.str() << std::endl;
    }
};
 
#endif

//  ============================= < КНОПКА РАБОТА С ПАПКОЙ > ===========================
            if (no_folder_sprite.getGlobalBounds().contains(pos.x, pos.y))//  при наезде зеленеет при отьезде белеет
            {
                no_folder_sprite.setColor(sf::Color(50, 150, 50));//красим КНОПКУ в невьебенный 
                
                //------------------                
                if (event.type == Event::MouseButtonPressed)//если нажата клавиша мыши     
                    if (event.key.code == Mouse::Left)
                    {
                        char tmp2[32]{};// Сохраним входной
                        strcpy(tmp2, strrchr(in_filename, '\\'));
                        *(strrchr(in_filename, L'\\')) = '\0';// Это папку удалять....
                        strcat(in_filename, "\\FOLD_FOR_CLIPS");
                        
                        if (no_folder)
                        {
                            if (cool_deleter(in_filename)) {// Это папку удалять....
                                char tmp[32]{};
                                strcpy(tmp, strrchr(out_filename, '\\'));
                                *(strrchr(out_filename, L'\\')) = '\0';
                                *(strrchr(out_filename, L'\\')) = '\0';
                                strcat(out_filename, tmp);
                                no_folder = false;
                            }
                        }
                        else if (!no_folder && _mkdir(in_filename) == 0) {
                            char tmp[32]{};
                            strcpy(tmp, strrchr(out_filename, '\\'));
                            *(strrchr(out_filename, L'\\')) = '\0';
                            strcat(out_filename, "\\FOLD_FOR_CLIPS");
                            strcat(out_filename, tmp);
                            no_folder = true;
                        }
                *(strrchr(in_filename, L'\\')) = '\0';//Восстановим входной ....
                strcat(in_filename, tmp2);
            }
                //printf("\n 2014 %s\n", in_filename);
                //printf(" 2014 %s\n", out_filename);
            }
            else no_folder_sprite.setColor(Color::White);// Кнопка no_muxung белеет