//
    bool HasSenario1Conditions(
        ENUM_X_CYCLES cycle,
        XBoxZone &box,
        XBoxZone &holderBox,
        ENUM_X_DIRECTION &dir,
        X121SMCStrategySignalProviderData &provider,
        ENUM_X_CYCLES holderCycle = X_CYCLE_NONE,
        int barIndex = 0 //
    )
    {
        //
        bool result = false;

        //
        // Fil Selected Data ...
        XPOIState cState;
        X121Conditions cXConditions;
        XC121SMCCycleHelper *cHelper;
        X121SMCCycleConditions cConditions;
        result = provider.SelectCycle(
            cycle,
            cState,
            cXConditions,
            cHelper,
            cConditions //
        );
        if (!result)
        {
            //
            cState.Clean();
            ZeroMemory(cHelper);
            cConditions.Clean();
            cXConditions.Clean();

            //
            return result;
        }
        Parse(cXConditions);

        //
        // Fil Selected Data ...
        XPOIState chState;
        X121Conditions chXConditions;
        XC121SMCCycleHelper *chHelper;
        X121SMCCycleConditions chConditions;
        if (holderCycle != X_CYCLE_NONE)
        {
            //
            result = provider.SelectCycle(
                holderCycle,
                chState,
                chXConditions,
                chHelper,
                chConditions //
            );
            if (!result)
            {
                //
                chState.Clean();
                ZeroMemory(chHelper);
                chConditions.Clean();
                chXConditions.Clean();

                //
                return result;
            }

            //
            Parse(chXConditions);
        }

        //
        // Normalize Args ...

        //
        box.Clean();
        holderBox.Clean();
        dir = X_DIRECTION_NONE;

        //
        if (barIndex < 0)
        {
            barIndex = 0;
        }

        //
        int idx = -1;
        int count = 0;
        bool has = false;

        //
        int zIDX = barIndex;
        int cIDX = zIDX + 1;
        int pIDX = cIDX + 1;

        //
        bool isBullish = false;
        bool isBearish = false;

        //
        XOHCL zBar;
        XOHCL cBar;
        XOHCL pBar;

        //
        // Initial Bars ...
        result = zBar.Init(
            cState.symbol,
            cState.period,
            barIndex //
        );
        result =
            result &&
            zBar.GetPreviousBar(cBar);
        result =
            result &&
            cBar.GetPreviousBar(pBar);
        if (!result)
        {
            //
            zBar.Clean();
            cBar.Clean();
            pBar.Clean();
            cState.Clean();
            chState.Clean();
            ZeroMemory(cHelper);
            cConditions.Clean();
            cXConditions.Clean();
            ZeroMemory(chHelper);
            chConditions.Clean();
            chXConditions.Clean();

            //
            return result;
        }

        //
        // Detecting Signal Conditions ...

        //
        bool isX3MAFastRejectUp =
            //
            cBar.low < cXConditions.x3maFastBuffer[cIDX] &&
            cBar.GetDown() > cXConditions.x3maFastBuffer[cIDX]
            //
            ;

        //
        bool isX3MAFastRejectDown =
            //
            cBar.high > cXConditions.x3maFastBuffer[cIDX] &&
            cBar.GetUp() < cXConditions.x3maFastBuffer[cIDX]
            //
            ;

        //
        // Find Breaker Bar ...
        datetime nearCloseOverX3MAFast = cHelper.GetNearestCloseOverX3MAFast(cBar);
        datetime nearCloseUnderX3MAFast = cHelper.GetNearestCloseUnderX3MAFast(cBar);
        bool hasNearestCloseOverX3MAFast =
            IsValid(nearCloseOverX3MAFast) &&
                    IsValid(nearCloseUnderX3MAFast)
                ? nearCloseOverX3MAFast > nearCloseUnderX3MAFast
            : IsValid(nearCloseOverX3MAFast)
                ? true
                : false;
        bool hasNearestCloseUnderX3MAFast =
            IsValid(nearCloseOverX3MAFast) &&
                    IsValid(nearCloseUnderX3MAFast)
                ? nearCloseUnderX3MAFast > nearCloseOverX3MAFast
            : IsValid(nearCloseUnderX3MAFast)
                ? true
                : false;

        //
        // Bullish Conditions ...
        isBullish =
            //
            // Base Condition ...
            (
                //
                cBar.IsBullish() &&
                isX3MAFastRejectUp &&
                cXConditions.isSMHKBullish &&
                hasNearestCloseOverX3MAFast &&
                cXConditions.xhkSMOpenBuffer[cIDX] < cXConditions.x3maMidBuffer[cIDX]
                //
                )
            //
            ;

        //
        // Bearish Conditions ...
        isBearish =
            //
            // Base Condition ...
            (
                //
                cBar.IsBearish() &&
                isX3MAFastRejectDown &&
                cXConditions.isSMHKBearish &&
                hasNearestCloseUnderX3MAFast &&
                cXConditions.xhkSMOpenBuffer[cIDX] > cXConditions.x3maMidBuffer[cIDX]
                //
                )
            //
            ;

        //
        // Filling Requirements ...
        result =
            isBullish ||
            isBearish;
        if (result)
        {
            //
            dir =
                isBullish
                    ? X_DIRECTION_BULLISH
                    : X_DIRECTION_BEARISH;

            //
            box.dir = dir;
            box.to = TimeCurrent();
            box.symbol = cXConditions.symbol;
            box.period = cXConditions.period;

            //
            int fromIDX = -1;
            if (isBullish)
            {
                //
                fromIDX = GetBarIndex(
                    cBar.symbol,
                    cBar.period,
                    nearCloseOverX3MAFast //
                );
            }
            else
            {
                //
                fromIDX = GetBarIndex(
                    cBar.symbol,
                    cBar.period,
                    nearCloseUnderX3MAFast //
                );
            }

            //
            if (IsValidIndex(fromIDX))
            {
                //
                box.from = iTime(
                    zBar.symbol,
                    zBar.period,
                    fromIDX //
                );
            }
            else
            {
                box.from = pBar.time;
            }

            //
            // Detect Holder Box ...
            XBoxZone tmpBoxes[];
            if (chState.IsValid())
            {
                //
                if (isBullish)
                {
                    //
                    // Demand Zones ...
                    XBoxZone tmp[];
                    ToBox(
                        chState.demandZones,
                        tmp //
                    );
                    Copy(
                        tmp,
                        tmpBoxes,
                        false //
                    );
                    Clean(tmp);

                    //
                    // Bullish Order Blocks ...
                    ToBox(
                        chState.bullishOrderBlocks,
                        tmp //
                    );
                    Copy(
                        tmp,
                        tmpBoxes,
                        false //
                    );
                    Clean(tmp);

                    //
                    // Bullish Fair Value Gaps ...
                    ToBox(
                        chState.bullishFairValueGaps,
                        tmp //
                    );
                    Copy(
                        tmp,
                        tmpBoxes,
                        false //
                    );
                    Clean(tmp);
                }
                else
                {
                    //
                    // Supply Zones ...
                    XBoxZone tmp[];
                    ToBox(
                        chState.supplyZones,
                        tmp //
                    );
                    Copy(
                        tmp,
                        tmpBoxes,
                        false //
                    );
                    Clean(tmp);

                    //
                    // Bearish Order Blocks ...
                    ToBox(
                        chState.bearishOrderBlocks,
                        tmp //
                    );
                    Copy(
                        tmp,
                        tmpBoxes,
                        false //
                    );
                    Clean(tmp);

                    //
                    // Bearish Fair Value Gaps ...
                    ToBox(
                        chState.bearishFairValueGaps,
                        tmp //
                    );
                    Copy(
                        tmp,
                        tmpBoxes,
                        false //
                    );
                    Clean(tmp);
                }
            }

            //
            has = HasChild(tmpBoxes);
            if (has)
            {
                //
                while (HasChild(tmpBoxes))
                {
                    //
                    idx = GetOldest(tmpBoxes);
                    has = IsValidIndex(idx);
                    if (!has)
                    {
                        break;
                    }

                    //
                    XBoxZone iBox = tmpBoxes[idx];
                    ArrayRemove(
                        tmpBoxes,
                        idx,
                        1 //
                    );

                    //
                    has = IsBoxInside(
                        box,
                        iBox //
                    );
                    if (has)
                    {
                        //
                        holderBox = iBox;
                        holderBox.to = TimeCurrent();
                        iBox.Clean();
                        break;
                    }

                    //
                    iBox.Clean();
                }
            }

            //
            Clean(tmpBoxes);

            //
            // Fix Box Upper and Lower based on Strategy ...

            //
            double points = GetPoints(box.symbol);
            double minPointsDiff = points * 20;

            //
            double prefferSL = 0;

            //
            // Other SL Conditions ...
            if (prefferSL <= 0)
            {
                //
                prefferSL = cHelper
                                .mX121Helper
                                .xhkHelper
                                .GetSMHKOpen(fromIDX);
            }

            //
            if (prefferSL > 0)
            {
                //
                box.upper =
                    isBullish
                        ? zBar.open
                        : prefferSL;

                //
                box.lower =
                    isBullish
                        ? prefferSL
                        : zBar.open;
            }

            //
            if (box.IsValid())
            {
                //
                XCBoxObject *iObj;
                bool isCreated = cHelper.mPOIDrawer.DrawBox(
                    box,
                    iObj //
                );
                if (isCreated)
                {
                    //
                    iObj.BoxWidth(2);
                    iObj.BoxFill(true);
                    iObj.BoxStyle(STYLE_DOT);

                    //
                    Print("Signal ...");
                }
            }

            //
            // Validate Conditions to Force Has Holder Box ...

            // //
            // result =
            //     result &&
            //     holderBox.IsValid() &&
            //     dir == holderBox.dir;

            // //
            // if (!result)
            // {
            //     //
            //     isBullish = false;
            //     isBearish = false;
            // }
        }

        //
        // Check All Conditions ...
        result =
            box.IsValid() &&
            HasDirection(dir) &&
            (isBullish ||
             isBearish);

        //
        // Cleanup Resources ...
        zBar.Clean();
        cBar.Clean();
        pBar.Clean();
        cState.Clean();
        chState.Clean();
        ZeroMemory(cHelper);
        cConditions.Clean();
        cXConditions.Clean();
        ZeroMemory(chHelper);
        chConditions.Clean();
        chXConditions.Clean();

        //
        return result;
    }

    ///////////////////////////////////////////////////////////////

            //
        // Detecting Signal Conditions ...

        //
        // Bullish Conditions ...
        isBullish =
            //
            // Base Condition ...
            (
                //
                provider.visionXConditions.isSMHKBullish && 
                provider.decisionXConditions.isSarBullish &&
                provider.decisionXConditions.isVWapFastBullish &&
                provider.decisionXConditions.isX3MaFastBullish &&
                provider.consolidationXConditions.isSMHKBullish && 
                provider.decisionXConditions.isSMHKSwitchedToBullish
                //
                )
            //
            ;

        //
        // Bearish Conditions ...
        isBearish =
            //
            // Base Condition ...
            (
                //
                provider.visionXConditions.isSMHKBearish &&
                provider.decisionXConditions.isSarBearish && 
                provider.decisionXConditions.isVWapFastBearish &&
                provider.decisionXConditions.isX3MaFastBearish &&
                provider.consolidationXConditions.isSMHKBearish &&
                provider.decisionXConditions.isSMHKSwitchedToBearish 
                //
                )
            //
            ;