//
        // Get Price Verification for Long ...
        isPriceVerified = 
            //
            // Starter ...
            true
            //
            && isHHVerified
            && signal.entry < hh
            && !isBigSharpOccured
            && signal.entry < candle0.high
            && MathAbs(signal.entry - hh) > 50 * _Point
            ;
                
        //
        isTPowVerified = 
            //
            // Starter ...
            true
            //
            && tPow.signal < MathMax(tPow.powerUp, tPow.powerDown)
            ;
        
        //
        isPSarVerified = 
            //
            // Starter ...
            true
            //
            && state0.psar < signal.entry
            ;

        //
        // bool isLastFastCrossSlowVerified =
        //     lastFastCrossOverSlowTime > 0
        //     && lastFastCrossUnderSlowTime > 0 
        //     ?
        //     MathAbs(GetLastFastCrossOverSlowBarIndex() - GetLastFastCrossUnderSlowBarIndex()) > (xTPWSwingLength * 2)
        //     :
        //     false
        //     ;

        //
        isStateVerified = 
            //
            // Start ...
            true
            //
            // && state0.fast > state1.fast
            // && state1.fast > state2.fast
            //
            // && state0.rangeFast > state0.rangeSlow
            // && state1.rangeFast > state1.rangeSlow
            // //
            // && state0.rangeWeight > state0.verifier
            // && state1.rangeWeight > state1.verifier
            // //
            // && state0.verifier < state0.rangeSlow
            // && state1.verifier < state1.rangeSlow
            //
            && MathAbs(state0.range - state0.rangeWeight) > 50 * _Point 
            //
            && MathAbs(state0.verifier - state0.rangeWeight) > 50 * _Point
            //
            // && (
            //     lastRangeCrossOverRangeWeightTime > 0
            //     && lastRangeCrossUnderRangeWeightTime > 0 
            //     ?
            //         //
            //         MathMin(
            //             GetLastRangeCrossOverRangeWeightBarIndex(),
            //             GetLastRangeCrossUnderRangeWeightBarIndex()
            //         ) - signalBarIndex > xTPWSwingLength
            //     :
            //         //
            //         false
            // )
            //
            // && ( 
            //     state0.range < state0.verifier 
            //     ?
            //         //
            //         false
            //     :
            //         //
            //         (
            //             state0.rangeWeight > state0.range 
            //             ?
            //                 //
            //                 MathAbs(state0.rangeWeight - state0.range) <= MathAbs(state0.range - state0.verifier)
            //             :
            //                 //
            //                  MathAbs(state0.rangeWeight - state0.range) <= MathAbs(state0.range - state0.verifier)
            //         )
            // )
            //
            // // && isLastFastCrossSlowVerified
            // && !(
            //     ll < llState.verifier 
            //     && hh > state0.verifier
            // )
            ;


// //
// datetime lastPriceOverVerifierTime;
// datetime lastFastCrossOverSlowTime;
// datetime lastPriceUnderVerifierTime;
// datetime lastPriceTouchVerifierTime;
// datetime lastFastCrossUnderSlowTime;
// datetime lastRangeCrossOverVerifierTime;
// datetime lastRangeCrossUnderVerifierTime;
// datetime lastRangeCrossOverRangeWeightTime;
// datetime lastRangeCrossUnderRangeWeightTime;
// datetime lastRangeWeightCrossOverVerifierTime;
// datetime lastRangeWeightCrossUnderVerifierTime;

// //
// datetime lastTPowAboveMaxVerifierTime;

// //
// // Find Crosses between fast and slow ...

// //
// bool isFastCrossOverSlow = 
//     state1.fast > state1.slow
//     && !(state2.fast > state2.slow)
// ;
// if (isFastCrossOverSlow) {
//     lastFastCrossOverSlowTime = barTime;
// }

// //
// bool isFastCrossUnderSlow = 
//     state1.fast < state1.slow
//     && !(state2.fast < state2.slow)
// ;
// if (isFastCrossUnderSlow) {
//     lastFastCrossUnderSlowTime = barTime;
// }

// //
// // Find Range and Verifier Cross ...

// //
// bool isRangeCrossOverVerifier =
//     state1.range > state1.verifier
//     && !(state2.range > state2.verifier)
// ;
// if (isRangeCrossOverVerifier) {
//     lastRangeCrossOverVerifierTime = barTime;
// }

// //
// bool isRangeCrossUnderVerifier =
//     state1.range < state1.verifier
//     && !(state2.range < state2.verifier)
// ;
// if (isRangeCrossUnderVerifier) {
//     lastRangeCrossUnderVerifierTime = barTime;
// }

// //
// // Find Crosses between range and rangeWeight ...

// //
// bool isRangeCrossOverRangeWeight = 
//     state1.range > state1.rangeWeight
//     && !(state2.range > state2.rangeWeight)
// ;
// if (isRangeCrossOverRangeWeight) {
//     lastRangeCrossOverRangeWeightTime = barTime;
// }

// //
// bool isRangeCrossUnderRangeWeight = 
//     state1.range < state1.rangeWeight
//     && !(state2.range < state2.rangeWeight)
// ;
// if (isRangeCrossUnderRangeWeight) {
//     lastRangeCrossUnderRangeWeightTime = barTime;
// }

// //
// // Find RangeWeight and Verifier Cross ...

// //
// bool isRangeWehigthCrossOverVerifier =
//     state1.rangeWeight > state1.verifier
//     && !(state2.rangeWeight > state2.verifier)
// ;
// if (isRangeWehigthCrossOverVerifier) {
//     lastRangeWeightCrossOverVerifierTime = barTime;
// }

// //
// bool isRangeWeightCrossUnderVerifier =
//     state1.rangeWeight < state1.verifier
//     && !(state2.rangeWeight < state2.verifier)
// ;
// if (isRangeWeightCrossUnderVerifier) {
//     lastRangeWeightCrossUnderVerifierTime = barTime;
// }

// //
// // Find Price Crosses by Verifier ...

// //
// bool isPriceOverVerifier = 
//     candle1.low > state1.verifier
//     && !(candle2.low > state1.verifier)
// ;
// if (isPriceOverVerifier) {
//     lastPriceOverVerifierTime = barTime;
// }

// //
// bool isPriceUnderVerifier = 
//         candle1.high < state1.verifier
//         && !(candle2.high < state1.verifier)
// ;
// if (isPriceUnderVerifier) {
//     lastPriceUnderVerifierTime = barTime;
// }

// //
// bool isPriceTouchVerifier = 
//     isPriceOverVerifier
//     || isPriceUnderVerifier
// ;

// //
// if (isPriceTouchVerifier) {
//     lastPriceTouchVerifierTime = barTime;
// }

// //
// bool isTPowUpperBelowMaxVerifier = MathMax(tPow1.powerUp, tPow1.powerDown) < tPowerMaxVerifier;
// bool isTPowUpperAboveMaxVerifier = MathMax(tPow1.powerUp, tPow1.powerDown) > tPowerMaxVerifier;
// if (isTPowUpperAboveMaxVerifier) {
//     lastTPowAboveMaxVerifierTime = barTime;
// }

// //
// int GetLastFastCrossOverSlowBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastFastCrossOverSlowTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastFastCrossOverSlowTime
//         );
//     }

//     //
//     return result;
// }

// //
// int GetLastFastCrossUnderSlowBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastFastCrossUnderSlowTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastFastCrossUnderSlowTime
//         );
//     }

//     //
//     return result;
// }

// //
// int GetLastRangeCrossOverVerifierBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastRangeCrossOverVerifierTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastRangeCrossOverVerifierTime
//         );
//     }

//     //
//     return result;
// }

// //
// int GetLastRangeCrossUnderVerifierBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastRangeCrossUnderVerifierTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastRangeCrossUnderVerifierTime
//         );
//     }

//     //
//     return result;
// }

// //
// int GetLastRangeCrossOverRangeWeightBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastRangeCrossOverRangeWeightTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastRangeCrossOverRangeWeightTime
//         );
//     }

//     //
//     return result;
// }

// //
// int GetLastRangeCrossUnderRangeWeightBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastRangeCrossUnderRangeWeightTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastRangeCrossUnderRangeWeightTime
//         );
//     }

//     //
//     return result;
// }

// //
// int GetLastRangeWeightCrossOverVerifierBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastRangeWeightCrossOverVerifierTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastRangeWeightCrossOverVerifierTime
//         );
//     }

//     //
//     return result;
// }

// //
// int GetLastRangeWeightCrossUnderVerifierBarIndex() {
//     //
//     int result = -1;

//     //
//     if (lastRangeWeightCrossUnderVerifierTime > 0) {
//         //
//         result = iBarShift(
//             _Symbol,
//             _Period,
//             lastRangeWeightCrossUnderVerifierTime
//         );
//     }

//     //
//     return result;
// }


    // //
    // // Detect Sharp Changes ...
    // double ll = GetMarketLowestLow(
    //     bar_index,
    //     xTPWSwingLength
    // );
    // double sharpDetectionValue = 
    //     xTPWSharpDetectionFactor * _Point;
    // double isSharpDetectionOccured = 
    //     MathAbs(candle0.low - ll) > sharpDetectionValue
    //     ;

    // //
    // // Retrieve State Min and Max ...
    // double stateMin0 = GetXTPWStateMin(state0);
    // double stateMax0 = GetXTPWStateMax(state0);
    // bool isStateDistanceValid = 
    //     MathAbs(stateMax0 - stateMin0) < sharpDetectionValue;

    // //
    // // Fast Slow Verification ...
    // //
    // double topBound = MathMax(state1.range, state1.rangeWeight);
    // topBound = MathMax(topBound, state1.verifier);

    // //
    // double bottomBound = MathMin(state1.range, state1.rangeWeight);
    // bottomBound = MathMin(bottomBound, state1.verifier);

    //
    // bool isFastSlowValid = 
    //     (
    //         state1.fast > topBound
    //         || state1.fast < bottomBound
    //     ) && (
    //         state1.slow > topBound
    //         || state1.slow < bottomBound
    //     );

    //
    bool longCondition1 = 
        // 
        // Condition 1 ...
        true
        //
        && tPow0.powerDown > tPow0.powerUp
        && state0.range > state0.verifier
        && state1.range > state1.verifier
        && state1.range > state1.rangeWeight
        && tPow0.powerDown > tPow1.powerDown
        && tPow1.powerDown > tPowerMaxVerifier
        && tPow2.powerDown < tPowerMaxVerifier
        && state1.rangeWeight > state1.verifier
        && !(
            (
                candle1.high > state1.verifier
                && candle1.low < state1.verifier
            ) || (
                candle1.low > state1.verifier
            )
        )
    ;

    //
    bool longCondition2 = 
        //
        // Condition 2 ...
        true
        //
        && tPow0.powerUp > tPow0.powerDown
        && tPow1.powerUp > tPow1.powerDown
        && tPow2.powerUp > tPow2.powerDown
        && tPow1.powerUp < tPowerVerifier
        //
        && state1.fast > state1.slow
        && state1.range > state1.verifier
        && state0.fast < state0.rangeWeight
        && state1.fast < state1.rangeWeight
        && state1.rangeWeight > state1.range
        && MathAbs(state1.rangeWeight - state1.range) > 
            (MathAbs(state1.range - state1.verifier) / 2)
        //
        && candle0.low > state0.verifier
        && candle1.low > state1.verifier
    ;

    //
    bool longCondition3 = 
        //
        // Condition 3 ...
        true
        //
        && isCrossOver
        && state0.fast >= state2.fast
        && state1.psar < candle1.low
        && state1.verifier < state1.fast
        //
        && MathMax(tPow1.powerUp, tPow1.powerDown) < tPowerMaxVerifier
    ;


//
// Get Minimum value of State ...
double GetXTPWStateMin(
    const XTPWMarketState &state
) {
    //
    double result = 0;

    //
    result = state.psar;
    result = MathMin(result, state.fast);
    result = MathMin(result, state.slow);
    result = MathMin(result, state.range);
    result = MathMin(result, state.verifier);
    result = MathMin(result, state.rangeWeight);

    //
    return result;
}

//
// Get Maximum value of State ...
double GetXTPWStateMax(
    const XTPWMarketState &state
) {
    //
    double result = 0;

    //
    result = state.psar;
    result = MathMax(result, state.fast);
    result = MathMax(result, state.slow);
    result = MathMax(result, state.range);
    result = MathMax(result, state.verifier);
    result = MathMax(result, state.rangeWeight);

    //
    return result;
}


//
//
        //
        // Count range weight Crosses ...
        if (
                //
                // Range Weight Cross Over Verifier ...
                (
                    iState1.rangeWeight > iState1.verifier
                    && !(iState2.rangeWeight > iState2.verifier)
                ) 
                || 
                //
                // Range Weight Cross Under Verifier ...
                (
                    iState1.rangeWeight < iState1.verifier
                    && !(iState2.rangeWeight < iState2.verifier)
                )
                ||
                //
                // Range Weight Cross Over Range ...
                (
                    iState1.rangeWeight > iState1.range
                    && !(iState2.rangeWeight > iState2.range)
                )
                ||
                //
                // Range Weight Cross Under Range ...
                (
                    iState1.rangeWeight < iState1.range
                    && !(iState2.rangeWeight < iState2.range)
                )
        ) {
            rangeWeightCrosses++;
        }

        //
        // Count Price above range ...
        if (
            iCandle.low > iState1.range
            || (
                iCandle.low < iState1.range
                && iCandle.high > iState1.range
            )
        ) {
            //
            priceAboveRange++;
        }

        //
        // Count Price above verifier ...
        if (
            iCandle.low > iState1.verifier
            || (
                iCandle.low < iState1.verifier
                && iCandle.high > iState1.verifier
            )
        ) {
            //
            priceAboveVerifier++;
        }

        //
        // Count between Range and Verifier ...
        double vUpper = MathMax(iState0.range, iState0.verifier);
        double vDowner = MathMin(iState0.range, iState0.verifier);
        if (
            !(
                iState0.fast > vUpper
                && iState0.slow > vUpper
            ) 
            && 
            !(
                iState0.fast < vDowner
                && iState0.slow < vDowner
            )
        ) {
            fastAndSlowBetweenRangeAndVerifier++;
        }

//
// Short ...
    //
    if (
        !enableXTPWSignalling
        || !xTPWWaitForShortSignals
    ) {
        return;
    }

    //
    datetime barTime = iTime(
        _Symbol,
        _Period,
        bar_index
    );

    //
    // Retrieve TPower State ...
    XTPOWStatee tPow0 = GetXTPowState(
        bar_index,
        xTPWSwingLength
    );
    XTPOWStatee tPow1 = GetXTPowState(
        bar_index + 1,
        xTPWSwingLength
    );
    XTPOWStatee tPow2 = GetXTPowState(
        bar_index + 2,
        xTPWSwingLength
    );

    //
    // Retrieve TPWMarket State ...
    XTPWMarketState state0 = GetXTPWMarketState(
        bar_index
    );
    XTPWMarketState state1 = GetXTPWMarketState(
        bar_index + 1
    );
    XTPWMarketState state2 = GetXTPWMarketState(
        bar_index + 2
    );

    //
    // Retrieve Candles ...
    XOHCL candle0 = GetCandleModel(bar_index);
    XOHCL candle1 = GetCandleModel(bar_index + 1);
    XOHCL candle2 = GetCandleModel(bar_index + 2);

    //
    bool isTPowUp = tPow2.powerUp > tPow2.powerDown;

    //
    double tPowUpper = MathMax(tPow2.powerUp, tPow2.powerDown);
    
    //
    bool startCondition = false;
    bool signalCondition = false;

    //
    startCondition = 
        //
        true
        //
        && tPow2.powerDown > tPowerVerifier
        ;

    //
    signalCondition = 
        //
        true
        //
        && tPow1.powerDown > tPow2.powerDown
        && tPow1.powerDown > tPowerMaxVerifier
        ;

    // //
    // bool isCrossOver = 
    //     state1.fast > state1.slow
    //     && !(state2.fast > state2.slow)
    //     ;

    // //
    // bool isCrossUnder = 
    //     state0.fast < state0.slow
    //     && state1.fast < state1.slow
    //     && !(state2.fast < state2.slow)
    //     ;
    
    //
    double tPowerMedian = tPowerMaxVerifier - tPowerVerifier / 2;

    //
    bool signalCondition1 =
        isCrossUnder
        ;

    //
    bool signalCondition2 = 
        //
        tPow0.powerDown > tPow0.powerUp
        //
        && tPow1.powerDown > tPow1.powerUp
        && tPow2.powerDown > tPow2.powerUp
        //
        && tPow0.powerDown > tPowerMedian
        && tPow1.powerDown > tPowerMedian
        && tPow2.powerDown > tPowerMedian
        //
        && tPow0.signal > tPow0.powerDown
        ;

    //
    if (
        (
            (
            startCondition
            && signalCondition
            ) || (
                signalCondition1
                || signalCondition2
            )
        )
        && xTPWShortConds.startTime == 0
        && xTPWShortConds.signalTime == 0
    ) {
        //
        xTPWShortConds.startTime = barTime;
        xTPWShortConds.signalTime = barTime;
        xTPWShortConds.entryTime = barTime;

        //
        return;
    }


//
// Short ...
        //
        isPSarVerified =
            // 
            // Starter ...
            true
            //
            && state0.psar > candle0.high
            && state0.psar > signal.entry
            ;

        //
        // Get Price Verification for Short ...
        isPriceVerified = 
            //
            // Starter ...
            true
            //
            && priceAboveRange < 1
            && priceAboveVerifier == 0
            ;

        //
        // Find Minimum Value of HH BarIndex Market State rangeWeight and verifier ...
        double hhValidationValue = MathMin(
            hhState.rangeWeight,
            hhState.verifier
        );
        bool isHHValidForShortSignal = 
            hh < hhValidationValue
            ;

        //
        isTPowVerified = 
            //
            // Starter ...
            true
            //
            && isHHValidForShortSignal
            //
            && aboveTPowerMaxVerifier < 4
            ;
        
        //
        isStateVerified = 
            //
            // Start ...
            true
            //
            && rangeWeightCrosses == 0
            //
            && state0.slow > state0.fast
            //
            && state0.range < state0.verifier
            //
            && state0.rangeWeight > state0.range
            && state0.rangeWeight < state0.verifier
            ;

        //
        result = 
            //
            // Starter Condition ...
            true
            //
            && isPSarVerified
            //
            && isTPowVerified
            //
            && isStateVerified
            //
            && isPriceVerified
            ;

    // //
    // int aboveTPowerVerifier = 0;
    // int abovePowerUpTPowerVerifier = 0;
    // int abovePowerDownTPowerVerifier = 0;

    // //
    // int aboveTPowerMaxVerifier = 0;
    // int abovePowerUpTPowerMaxVerifier = 0;
    // int abovePowerDownTPowerMaxVerifier = 0;

    // //
    // int belowTPowerVerifier = 0;
    // int belowPowerUpTPowerVerifier = 0;
    // int belowPowerDownTPowerVerifier = 0;

    // //
    // int belowTPowerMaxVerifier = 0;
    // int belowPowerUpTPowerMaxVerifier = 0;
    // int belowPowerDownTPowerMaxVerifier = 0;

    // //
    // double powerUpSum = 0;
    // double powerDownSum = 0;

    // //
    // int priceAboveRange = 0;
    // int priceAboveVerifier = 0;
    // int fastAndSlowBetweenRangeAndVerifier = 0;

    // //
    // int rangeWeightCrosses = 0;

    // //
    // for (int i = signalBarIndex; i < signalBarIndex + xTPWSwingLength; i++) {
    //     //
    //     XOHCL iCandle = GetCandleModel(i);

    //     //
    //     XTPOWStatee iTPow = GetXTPowState(
    //         i,
    //         xTPWSwingLength
    //     );

    //     //
    //     double isTPowUp = iTPow.powerUp > iTPow.powerDown;

    //     //
    //     double tPowUpper = MathMax(iTPow.powerUp, iTPow.powerDown);

    //     //
    //     // Summarise ...
    //     powerUpSum += iTPow.powerUp;
    //     powerDownSum += iTPow.powerDown;

    //     //
    //     XTPWMarketState iState0 = GetXTPWMarketState(
    //         i
    //     );
    //     XTPWMarketState iState1 = GetXTPWMarketState(
    //         i + 1
    //     );
    //     XTPWMarketState iState2 = GetXTPWMarketState(
    //         i + 2
    //     );


    //     //
    //     // Count Above TPow Verifier ...
    //     if (tPowUpper > tPowerVerifier) {
    //         //
    //         aboveTPowerVerifier++;

    //         //
    //         if (isTPowUp) {
    //             abovePowerUpTPowerVerifier++;
    //         } else {
    //             abovePowerDownTPowerVerifier++;
    //         }
    //     } else if (tPowUpper < tPowerVerifier) {
    //         //
    //         belowTPowerVerifier++;

    //         //
    //         if (isTPowUp) {
    //             belowPowerUpTPowerVerifier++;
    //         } else {
    //             belowPowerDownTPowerVerifier++;
    //         }
    //     }

    //     //
    //     // Count Above TPow Max Verifier ...
    //     if (tPowUpper > tPowerMaxVerifier) {
    //         //
    //         aboveTPowerMaxVerifier++;

    //         //
    //         if (isTPowUp) {
    //             abovePowerUpTPowerMaxVerifier++;
    //         } else {
    //             abovePowerDownTPowerMaxVerifier++;
    //         }
    //     } else if (tPowUpper < tPowerMaxVerifier) {
    //         //
    //         belowTPowerMaxVerifier++;

    //         //
    //         if (isTPowUp) {
    //             belowPowerUpTPowerMaxVerifier++;
    //         } else {
    //             belowPowerDownTPowerMaxVerifier++;
    //         }
    //     }
    // }



    // //
    // int doubleMarketLength = (xTPWSwingLength * 2);
    // int verifierLength = GetDailyCandleCount();
    // int rangeLength = verifierLength / 2;

    // //
    // // Find Highest High ...

    // //
    // double rangeHH = GetMarketHighestHigh(
    //     signalBarIndex,
    //     rangeLength
    // );

    // //
    // double verifierHH = GetMarketHighestHigh(
    //     signalBarIndex,
    //     verifierLength
    // );

    // //
    // // Find HH Bar Index ...
    // int hhBarIndex = iHighest(
    //     _Symbol,
    //     _Period,
    //     MODE_HIGH,
    //     xTPWSwingLength,
    //     signalBarIndex
    // );

    // //
    // // Find HH ...
    // double hh = iHigh(
    //     _Symbol,
    //     _Period,
    //     hhBarIndex
    // );

    // //
    // // Retrieve Market State on HH Bar Index ...
    // XTPWMarketState hhState = GetXTPWMarketState(
    //     hhBarIndex
    // );

    // //
    // // Retrieve TPow State on HH Bar Index ...
    // XTPOWStatee hhTPow = GetXTPowState(
    //     hhBarIndex,
    //     xTPWSwingLength
    // );

    // //
    // // Find Lowest Low ...

    // //
    // double rangeLL = GetMarketLowestLow(
    //     signalBarIndex,
    //     rangeLength
    // );

    // //
    // double verifierLL = GetMarketLowestLow(
    //     signalBarIndex,
    //     verifierLength
    // );

    // //
    // // Find LL Bar Index ...
    // int llBarIndex = iLowest(
    //     _Symbol,
    //     _Period,
    //     MODE_LOW,
    //     xTPWSwingLength,
    //     signalBarIndex
    // );

    // //
    // // Find LL ...
    // double ll = iLow(
    //     _Symbol,
    //     _Period,
    //     llBarIndex
    // );

    // //
    // // Retrieve Market State on LL Bar Index ...
    // XTPWMarketState llState = GetXTPWMarketState(llBarIndex);

    // //
    // // Retrieve TPow State on LL Bar Index ...
    // XTPOWStatee llTPow = GetXTPowState(
    //     llBarIndex,
    //     xTPWSwingLength
    // );

    // //
    // // Find Sharp Changes ...
    // double diffChange = (hh - ll);
    // double sharpDetectionValue = 
    //     (xTPWSharpDetectionFactor * _Point);
    // bool isBigSharpOccured = 
    //     diffChange > sharpDetectionValue;
    //     ;
    
    // //
    // bool isHHVerified =
    //     !(
    //         hh == rangeHH
    //         && rangeHH == verifierHH
    //     )
    //     || 
    //     (
    //         hh > rangeHH
    //         || hh > verifierHH
    //     );
    
    // //
    // bool isLLVerified = 
    //     !(
    //         ll == rangeLL
    //         && rangeLL == verifierLL
    //     ) 
    //     ||
    //     (
    //         ll < rangeLL
    //         || ll < verifierLL
    //     );