//
        // Select a Supply Zone which Price is Inside it ...
        XZone aSupplyZone;
        XZone aSupplyZoneTrigger;
        bool hasSupplyZoneArroundCBar = false;
        bool hasTriggerSupplyZoneArroundCBar = false;
        int aSupplyZonesCount = ArraySize(_15MState.supplyZones);
        int aSupplyZonesTriggerCount = ArraySize(_5MState.supplyZones);
        if (!hasSupplyZoneArroundCBar ||
            !hasTriggerSupplyZoneArroundCBar)
        {
            for (int i = 0; i < aSupplyZonesCount; i++)
            {
                //
                XZone iZone = _15MState.supplyZones[i];

                //
                bool canSetZone = (!hasSupplyZoneArroundCBar &&
                                   iZone.lower < cBar.low &&
                                   iZone.upper > cBar.high) ||
                                  (hasSupplyZoneArroundCBar &&
                                   aSupplyZone.lower < cBar.low &&
                                   aSupplyZone.upper > cBar.high &&
                                   iZone.lower < cBar.low &&
                                   iZone.upper > cBar.high &&
                                   iZone.GetRange() < aSupplyZone.GetRange());
                if (canSetZone &&
                    !hasTriggerSupplyZoneArroundCBar &&
                    IsValidSize(aSupplyZonesTriggerCount))
                {
                    //
                    for (int j = 0; j < aSupplyZonesTriggerCount; j++)
                    {
                        //
                        XZone jZone = _5MState.supplyZones[j];

                        //
                        bool canSetTriggerZone = (!hasTriggerSupplyZoneArroundCBar &&
                                                  jZone.lower < cBar.low &&
                                                  jZone.upper > cBar.high) ||
                                                 (hasTriggerSupplyZoneArroundCBar &&
                                                  aSupplyZoneTrigger.lower < cBar.low &&
                                                  aSupplyZoneTrigger.upper > cBar.high &&
                                                  jZone.lower < cBar.low &&
                                                  jZone.upper > cBar.high &&
                                                  jZone.GetRange() < aSupplyZoneTrigger.GetRange());
                        if (canSetTriggerZone)
                        {
                            //
                            iZone.to = cTime;
                            jZone.to = cTime;
                            aSupplyZone = iZone;
                            aSupplyZoneTrigger = jZone;
                            hasSupplyZoneArroundCBar = true;
                            hasTriggerSupplyZoneArroundCBar = true;

                            //
                            break;
                        }
                    }
                }
            }
        }

        //
        // XZone supplyZone;
        // int supplyZonesCount = ArraySize(_5MState.supplyZones);
        // bool hasSupplyZoneOverCBar = IsValidSize(supplyZonesCount);
        // if (hasSupplyZoneOverCBar)
        // {
        //     //
        //     hasSupplyZoneOverCBar = false;
        //     for (int i = 0; i < supplyZonesCount; i++)
        //     {
        //         //
        //         XZone iZone = _5MState.supplyZones[i];

        //         //
        //         if (!hasSupplyZoneOverCBar &&
        //             iZone.lower > cBar.high)
        //         {
        //             //
        //             iZone.to = cTime;
        //             supplyZone = iZone;
        //             hasSupplyZoneOverCBar = true;

        //             // //
        //             // break;
        //         }
        //     }
        // }

        //
        XZone demandZone;
        int demandZonesCount = ArraySize(_5MState.demandZones);
        bool hasDemandZoneUnderCBar = IsValidSize(demandZonesCount);
        if (hasDemandZoneUnderCBar)
        {
            //
            hasDemandZoneUnderCBar = false;
            for (int i = 0; i < demandZonesCount; i++)
            {
                //
                XZone iZone = _5MState.demandZones[i];

                //
                if (!hasDemandZoneUnderCBar &&
                    iZone.upper < cBar.low)
                {
                    //
                    iZone.to = cTime;
                    demandZone = iZone;
                    hasDemandZoneUnderCBar = true;

                    //
                    break;
                }
            }
        }

        //
        XOHCL swingHigh;
        int swingHighsCount = ArraySize(_5MState.swingHighs);
        bool hasSwingHighOverCBar = IsValidSize(swingHighsCount);
        if (hasSwingHighOverCBar)
        {
            //
            hasSwingHighOverCBar = false;
            for (int i = 0; i < swingHighsCount; i++)
            {
                //
                XOHCL iBar = _5MState.swingHighs[i];

                //
                if (!hasSwingHighOverCBar &&
                    iBar.high > cBar.high)
                {
                    //
                    swingHigh = iBar;
                    hasSwingHighOverCBar = true;

                    //
                    break;
                }
            }
        }

        //
        XOHCL swingLow;
        int swingLowsCount = ArraySize(_5MState.swingLows);
        bool hasSwingLowUnderCBar = IsValidSize(swingLowsCount);
        if (hasSwingLowUnderCBar)
        {
            //
            hasSwingLowUnderCBar = false;
            for (int i = 0; i < swingLowsCount; i++)
            {
                //
                XOHCL iBar = _5MState.swingLows[i];

                //
                if (!hasSwingLowUnderCBar &&
                    iBar.low < cBar.low)
                {
                    //
                    swingLow = iBar;
                    hasSwingLowUnderCBar = true;

                    //
                    break;
                }
            }
        }

        //
        XOHCL bullishRejectionBar;
        XOHCL bearishRejectionBar;
        bool hasBullishRejectionBarUnderCBar = false;
        bool hasBearishRejectionBarOverCBar = false;
        int rejectionBarsCount = ArraySize(_5MState.rejectionBars);
        if (IsValidSize(rejectionBarsCount))
        {
            //
            for (int i = 0; i < rejectionBarsCount; i++)
            {
                //
                XOHCL iBar = _5MState.rejectionBars[i];

                //
                bool isBullish = iBar.GetLowShadow() > iBar.GetHighShadow();
                bool isBearish = iBar.GetHighShadow() > iBar.GetLowShadow();

                //
                if (isBullish &&
                    !hasBullishRejectionBarUnderCBar &&
                    iBar.high < cBar.low)
                {
                    //
                    bullishRejectionBar = iBar;
                    hasBullishRejectionBarUnderCBar = true;
                }

                //
                if (isBearish &&
                    !hasBearishRejectionBarOverCBar &&
                    iBar.low > cBar.high)
                {
                    //
                    bearishRejectionBar = iBar;
                    hasBearishRejectionBarOverCBar = true;
                }
            }
        }




















        //
        // XZone bullishOB;
        // XZone bearishOB;
        // XPOIState state = _15MState;
        // int obsCount = ArraySize(state.bullishOrderBlocks);
        // // for (int i = 0; i < obsCount; i++)
        // {
        //     //
        //     XZone iZone = state.bullishOrderBlocks[i];
        //     bool canRefine = CanRefineZone(
        //         iZone,
        //         bullishOB,
        //         cBar //
        //     );

        //     //
        //     if (canRefine &&
        //         isVWapBullish)
        //     {
        //         //
        //         iZone.to = cTime;
        //         XCBullishOrderBlockObject *iObj;
        //         bool isCreated = mPOIDrawer.CreateBullishOrderBlock(
        //             iZone,
        //             iObj //
        //         );
        //         if (isCreated)
        //         {
        //             mDrawnObjects.Add(iObj);
        //         }
        //     }
        // }
        // obsCount = ArraySize(state.bearishOrderBlocks);
        // for (int i = 0; i < obsCount; i++)
        // {
        //     //
        //     XZone iZone = state.bearishOrderBlocks[i];
        //     bool canRefine = CanRefineZone(
        //         iZone,
        //         bearishOB,
        //         cBar //
        //     );

        //     //
        //     if (canRefine &&
        //         isVWapBearish)
        //     {
        //         //
        //         iZone.to = cTime;
        //         XCBearishOrderBlockObject *iObj;
        //         bool isCreated = mPOIDrawer.CreateBearishOrderBlock(
        //             iZone,
        //             iObj //
        //         );
        //         if (isCreated)
        //         {
        //             mDrawnObjects.Add(iObj);
        //         }
        //     }
        // }

        // int m15Count = ArraySize(_15MState.resistanceZones);

        //
        // Detect Resistance ....
        // if (!mConditions.resistance.IsValid())
        // {
        //     //
        //     // XZone h4Resistance;
        //     // XZone m15Resistance;
        //     // XZone m5Resistance;

        //     // //
        //     // int h4Count = ArraySize(_4HState.resistanceZones);
        //     // int m15Count = ArraySize(_15MState.resistanceZones);
        //     // int m5Count = ArraySize(_5MState.resistanceZones);

        //     // //
        //     // for (int i = 0; i < h4Count; i++)
        //     // {
        //     //     //
        //     //     XOHCL iBar = _4HState.resistanceZones[i];
        //     // }
        // }