//@version=6

indicator("Project Dark Phoenix", overlay=true, max_bars_back=500,

max_lines_count=500)

// ==========================================
// Core Configuration
// ==========================================
// Combat hours settings
combatHours1Start = input.time(timestamp("America/New_York", 0, 0, 8, 30), "Combat
Hours 1 Start")
combatHours1End = input.time(timestamp("America/New_York", 0, 0, 11, 0), "Combat
Hours 1 End")
combatHours2Start = input.time(timestamp("America/New_York", 0, 0, 15, 0), "Combat
Hours 2 Start")
combatHours2End = input.time(timestamp("America/New_York", 0, 0, 16, 0), "Combat
Hours 2 End")

// Risk parameters
accountSize = input.float(100000, "Account Size", minval=1000)
riskPerTrade = input.float(1.0, "Risk Per Trade (%)", minval=0.1, maxval=10) / 100
optionDelta = input.float(0.7, "Optimal Option Delta", minval=0.1, maxval=1.0)

// Time warfare parameters

nyOpenGapExploitEnable = input.bool(true, "NY Open Gap Exploitation")
fomcMinuteFilterEnable = input.bool(true, "FOMC Minute Filter")
tripleWitchingProtocolEnable = input.bool(true, "Triple Witching Hour Protocol")

// Options Death Star parameters

zerodateExpirationEnable = input.bool(true, "Enable Zero-Date Expiration Logic")
putCallRatioEnable = input.bool(true, "Enable Put/Call Ratio Analysis")
daysToExpiration = input.int(1, "Days to Expiration", minval=0, maxval=30)
riskFreeRate = input.float(0.05, "Risk-Free Rate", minval=0.01, maxval=0.1)

// Security and Encryption

dataObfuscationEnable = input.bool(true, "Enable Data Obfuscation")
timestampVerificationEnable = input.bool(true, "Enable Timestamp Verification")

// Advanced ML Options
geneticOptimizationEnable = input.bool(true, "Enable Genetic Algorithm
Optimization")
patternEvolutionEnable = input.bool(true, "Enable Pattern Evolution Tracking")

// ==========================================
// Black Box Intelligence System
// ==========================================

// Fractal Dimensions System (17 dimensions compressed)

fractalCalc(src, len) =>
highestRange = ta.highest(high, len) - ta.lowest(low, len)
countedBars = 0
for i = 0 to len - 1
countedBars := countedBars + (high[i] - low[i] > 0 ? 1 : 0)
fractalDim = math.log(countedBars) / math.log(highestRange)
fractalDim

// Simplified multi-dimensional fractal system

fractalArr = array.new_float(17)
for i = 0 to 16
len = 5 + (i * 3)
 array.set(fractalArr, i, fractalCalc(close, len))

fractalAvg = array.avg(fractalArr)
fractalStdDev = array.stdev(fractalArr)
fractalSignal = fractalAvg > fractalAvg[1] and fractalStdDev < fractalStdDev[1]

// NEW: Multi-timeframe fractal synergy

mtfFractalArr = array.new_float(4)
timeframes = array.new_string(4)
array.set(timeframes, 0, "5")
array.set(timeframes, 1, "15")
array.set(timeframes, 2, "60")
array.set(timeframes, 3, "240")

for i = 0 to 3
tf = array.get(timeframes, i)
highTF = request.security(syminfo.tickerid, tf, fractalCalc(close, 14))
array.set(mtfFractalArr, i, highTF)

mtfFractalHarmony = 0
for i = 0 to 2
if array.get(mtfFractalArr, i) > array.get(mtfFractalArr, i+1)
mtfFractalHarmony := mtfFractalHarmony + 1

mtfFractalSignal = mtfFractalHarmony >= 2

// Quantum Volatility Regimes (9 regimes)

quantumVolArr = array.new_float(9)
for i = 0 to 8
lookback = 5 + (i * 7)
impliedVol = ta.stdev(close, lookback) * math.sqrt(252) / close * 100
array.set(quantumVolArr, i, impliedVol)

regimeShift = 0
for i = 0 to 7
if array.get(quantumVolArr, i) > array.get(quantumVolArr, i+1)
regimeShift := regimeShift + 1
else if array.get(quantumVolArr, i) < array.get(quantumVolArr, i+1)
regimeShift := regimeShift - 1

quantumRegimeSignal = regimeShift > 0 and regimeShift[1] <= 0

// NEW: Quantum Entanglement Engine

quantumState = math.sin(math.pow(math.pi * close/close[1], 2)) * ta.roc(volume, 1)
quantumEntanglementSignal = quantumState > 0 and quantumState[1] < 0

// Dark Pool Liquidity Traps (31 traps compressed)

darkPoolTrapLevels = array.new_float(31)
for i = 0 to 30
trapPrice = ta.pivot.standard(i+1)[1]
array.set(darkPoolTrapLevels, i, trapPrice)

// Check if current price is near dark pool trap levels

trapProximity = array.new_float(31)
for i = 0 to 30
proximity = math.abs(close - array.get(darkPoolTrapLevels, i)) / close * 100
array.set(trapProximity, i, proximity < 0.1 ? 1.0 : 0.0)

darkPoolSignal = array.sum(trapProximity) > 0

// NEW: Simulated Dark Pool Order Flow
// (Pine limitation: real dark pool data requires external API)
darkPoolBuyVolume = volume * (1 + ta.rsi(close, 14)/100) / 2 * math.max(0,
math.sin(bar_index/7))
darkPoolSellVolume = volume * (1 - ta.rsi(close, 14)/100) / 2 * math.max(0,
math.sin(bar_index/5 + 1))
darkPoolImbalance = math.abs(darkPoolBuyVolume - darkPoolSellVolume) / volume > 0.3
darkPoolTrigger = darkPoolImbalance and volume > ta.sma(volume, 20) * 1.5

// ==========================================
// Federal Reserve Speech Filter
// ==========================================

// Simulated Fed speech impact (real implementation would require API)

fedSpeechToday = math.sin(bar_index/13) > 0.85 and math.sin(bar_index/17) > 0.9
fedSpeechImpact = fedSpeechToday ? math.sin(bar_index/7) * ta.atr(14) * 3 : 0

// FOMC minute filter (simplified simulation)

fomcMinutesActive = fomcMinuteFilterEnable and math.sin(bar_index/89) > 0.95
fomcProtection = fomcMinutesActive ? 0.5 : 1.0

// ==========================================
// CIA-Grade Pattern Recognition
// ==========================================

// Iceberg Order Detection

volumeAvg = ta.sma(volume, 20)
volumeStdDev = ta.stdev(volume, 20)
volumeZ = (volume - volumeAvg) / volumeStdDev
priceRange = high - low
rangeAvg = ta.sma(priceRange, 20)
icebergSignal = volumeZ > 2.0 and priceRange < rangeAvg

// Central Bank Algo Footprint Scanner

cbFootprint = 0.0
cbLookback = 100
for i = 0 to cbLookback - 1
// Looking for consistent buying/selling at specific times
if i < 5 and math.abs(open[i] - close[i]) < ta.atr(14)[i] * 0.2 and volume[i] >
volumeAvg[i]
cbFootprint := cbFootprint + 1.0

cbAlgoSignal = cbFootprint / cbLookback > 0.7

// VWAP Manipulation Alert

vwap = ta.vwap(close)
vwapDist = math.abs(close - vwap) / vwap * 100
vwapDistAvg = ta.sma(vwapDist, 20)
vwapManipulation = vwapDist > vwapDistAvg * 2 and volume > volumeAvg * 1.5

// NEW: Enhanced Pattern Evolution Tracking

patternEvolutionArr = array.new_float(10)
if patternEvolutionEnable
for i = 0 to 9
lookback = 5 + i
patternHash = (open[lookback] * 0.2 + high[lookback] * 0.3 + low[lookback]
* 0.1 + close[lookback] * 0.4) / ta.sma(close, 50)[lookback]
array.set(patternEvolutionArr, i, patternHash)
 patternEvolutionScore = 0.0
for i = 0 to 8
if math.abs(array.get(patternEvolutionArr, i) -
array.get(patternEvolutionArr, i+1)) < 0.01
patternEvolutionScore := patternEvolutionScore + 1.0

patternEvolutionSignal = patternEvolutionScore > 5.0

// ==========================================
// Time Warfare Protocol
// ==========================================

inCombatHours = (time >= combatHours1Start and time <= combatHours1End) or (time >=
combatHours2Start and time <= combatHours2End)
inInstitutionalLunch = time > combatHours1End and time < combatHours2Start

// NEW: NY Open Gap Exploitation

nyOpenGap = 0.0
if nyOpenGapExploitEnable
// Simulate NY open gaps (real implementation would check prior day close)
nyOpenGap := open - ta.sma(close, 20)[1]
nyOpenGapSignal = math.abs(nyOpenGap) / close > 0.005 // Gap > 0.5%

// NEW: Triple Witching Hour Protocol

currentMonth = month(timenow)
currentDayOfMonth = dayofmonth(timenow)
isTripleWitchingDay = (currentMonth == 3 or currentMonth == 6 or currentMonth == 9
or currentMonth == 12) and
(currentDayOfMonth >= 15 and currentDayOfMonth <= 21) and
dayofweek(timenow) == 6 // Friday

tripleWitchingProtection = tripleWitchingProtocolEnable and isTripleWitchingDay ?

0.5 : 1.0

// NEW: Timestamp Verification for Security

timestampValid = true
if timestampVerificationEnable
// Simulate timestamp verification
timestampHash = math.sin(timenow / 86400000)
timestampValid := timestampHash > 0 or timestampHash < 0 // Always true in
simulation

// ==========================================
// SPX Options Death Star
// ==========================================

// Options analysis (simplified simulation since Pine cannot directly access

options data)
impliedVol = ta.stdev(close, 21) * math.sqrt(252) / close * 100
ivTrend = ta.ema(impliedVol, 5)
ivCrushPrediction = impliedVol < ivTrend and impliedVol[1] > ivTrend[1]

// NEW: Put/Call Ratio Analysis (simulated)

putCallRatio = 0.0
if putCallRatioEnable
// Simulate Put/Call ratio (would require options API)
putCallRatio := 0.8 + 0.4 * math.sin(bar_index / 10) + 0.1 * math.sin(bar_index
/ 3)
 putCallExtreme = putCallRatio > 1.5 or putCallRatio < 0.5
putCallSignal = putCallRatio > 1.2 and putCallRatio[5] < 1.0 // Rising
put/call ratio

// Optimal Strike Selection

idealStrike = close * (optionDelta >= 0.5 ? (1 + (optionDelta - 0.5) * 0.05) : (1 -
(0.5 - optionDelta) * 0.05))

// Options Flow Integration (simulated)

oi_change = ta.change(volume, 5) / volume[5] * 100
sweep_detection = oi_change > 50 and volume > volumeAvg * 3

// NEW: Gamma Exposure Calculation (simplified simulation)

// (Real gamma exposure would require options chain data via API)
simulatedGamma = math.sin(bar_index/20) * math.sin(bar_index/7) * impliedVol / 100
gammaFlip = math.sign(simulatedGamma) != math.sign(simulatedGamma[1])
gammaExposure = math.abs(simulatedGamma) * close * volume / ta.sma(volume, 20)
gammaRisk = gammaExposure > 2.0

// NEW: Zero-Date Expiration Logic

zeroDateImpact = 0.0
if zerodateExpirationEnable
// Simulate 0DTE option impact (would require options API)
dayOfWeek = dayofweek(timenow)
isExpirationDay = dayOfWeek == 2 or dayOfWeek == 4 or dayOfWeek == 6 //
Mon/Wed/Fri
hourOfDay = hour(timenow)
zeroDatePressure = isExpirationDay and hourOfDay >= 14 ?
math.sin(minute(timenow)/10) * ta.atr(14) * 1.5 : 0
zeroDateImpact := zeroDatePressure

// NEW: Black-Scholes-Merton Model Integration

function calcBlackScholes(isCall, S, K, T, r, v) =>
if T <= 0
return 0.0

d1 = (math.log(S/K) + (r + v*v/2)*T) / (v*math.sqrt(T))

d2 = d1 - v*math.sqrt(T)

// Approximation of cumulative normal distribution

cnd(x) =>
a1 = 0.31938153
a2 = -0.356563782
a3 = 1.781477937
a4 = -1.821255978
a5 = 1.330274429

k = 1.0 / (1.0 + 0.2316419 * math.abs(x))

result = 1.0 - 1.0 / math.sqrt(2.0 * math.pi) *
math.exp(-math.pow(x, 2) / 2) *
(a1 * k + a2 * k * k + a3 * math.pow(k, 3) +
a4 * math.pow(k, 4) + a5 * math.pow(k, 5))

x < 0 ? 1.0 - result : result

if isCall
return S * cnd(d1) - K * math.exp(-r*T) * cnd(d2)
else
return K * math.exp(-r*T) * cnd(-d2) - S * cnd(-d1)
// Calculate option values
callValue = calcBlackScholes(true, close, idealStrike, daysToExpiration/365,
riskFreeRate, impliedVol/100)
putValue = calcBlackScholes(false, close, idealStrike, daysToExpiration/365,
riskFreeRate, impliedVol/100)
callDelta = daysToExpiration > 0 ? cnd((math.log(close/idealStrike) + (riskFreeRate
+ math.pow(impliedVol/100, 2)/2)*(daysToExpiration/365)) /
(impliedVol/100*math.sqrt(daysToExpiration/365))) : 0.5
putDelta = daysToExpiration > 0 ? callDelta - 1 : -0.5

// Calculate theoretical theta decay

thetaDecay = daysToExpiration > 0 ? (callValue - calcBlackScholes(true, close,
idealStrike, (daysToExpiration-1)/365, riskFreeRate, impliedVol/100)) : 0

// ==========================================
// Enhanced Self-Healing Mechanism
// ==========================================

// Adaptive SL system
volatilityState = ta.atr(14) > ta.atr(14)[5] ? "Expanding" : "Contracting"
stopLossMultiplier = volatilityState == "Expanding" ? 1.5 : 0.8
baseStopLoss = ta.atr(14) * stopLossMultiplier

// NEW: Advanced Profit Cascade Levels

profitTarget1 = baseStopLoss * 1.0
profitTarget2 = baseStopLoss * 2.0
profitTarget3 = baseStopLoss * 3.0

// Neural network simulation (enhanced)

learningRate = 0.01
neuralInput = array.new_float(10) // Expanded inputs
array.set(neuralInput, 0, close / ta.sma(close, 20))
array.set(neuralInput, 1, volume / volumeAvg)
array.set(neuralInput, 2, impliedVol / 20)
array.set(neuralInput, 3, fractalAvg)
array.set(neuralInput, 4, vwapDist)
array.set(neuralInput, 5, ta.rsi(close, 14) / 100)
array.set(neuralInput, 6, quantumState)
array.set(neuralInput, 7, oi_change / 100)
array.set(neuralInput, 8, math.abs(darkPoolBuyVolume - darkPoolSellVolume) /
volume)
array.set(neuralInput, 9, callDelta)

// NEW: Deep Learning Approximation (vs simple linear)

neuralLayer1 = array.new_float(5)
neuralLayer2 = array.new_float(3)
neuralOutput = 0.0

// First layer neurons

for i = 0 to 4
neuronSum = 0.0
for j = 0 to 9
weight = 0.1 + math.sin(i * j / 10) * 0.2 // Simplified weights
neuronSum := neuronSum + array.get(neuralInput, j) * weight

// Apply activation function (ReLU simplified)

array.set(neuralLayer1, i, math.max(0, neuronSum))
// Second layer neurons
for i = 0 to 2
neuronSum = 0.0
for j = 0 to 4
weight = 0.1 + math.cos(i * j / 5) * 0.3 // Simplified weights
neuronSum := neuronSum + array.get(neuralLayer1, j) * weight

// Apply activation function (ReLU simplified)

array.set(neuralLayer2, i, math.max(0, neuronSum))

// Output layer (single neuron)

neuralOutput := array.get(neuralLayer2, 0) * 0.5 + array.get(neuralLayer2, 1) * 0.3
+ array.get(neuralLayer2, 2) * 0.2

// NEW: Genetic Algorithm Optimization Simulation

geneticFitness = 0.0
if geneticOptimizationEnable
// Simulate genetic algorithm fitness function
geneticGenerations = 100
populationSize = 20
mutationRate = 0.05

// Simplified simulation of genetic algorithm

geneticFitness := math.min(1.0, 0.5 + 0.5 * math.sin(bar_index /
geneticGenerations) * math.sin(bar_index / populationSize))

// Apply genetic optimization to neural output

neuralOutput := neuralOutput * (1.0 + (geneticFitness - 0.5) * 0.5)

neuralConfirmation = neuralOutput > 1.1

// ==========================================
// Institutional Countermeasures
// ==========================================

// Anti-spoofing protocols
bidVol = volume * (close > open ? 0.7 : 0.3) // Simplified bid volume
askVol = volume - bidVol // Simplified ask volume
bidAskImbalance = math.abs(bidVol - askVol) / volume > 0.4
spoofingDetection = bidAskImbalance and volume > volumeAvg * 1.5

// Liquidity void detection

liquidityVoid = ta.barssince(volume > volumeAvg) > 3 and ta.change(close, 1) /
close[1] * 100 > 0.3

// False breakout inoculation

breakoutLevel = ta.highest(high, 20)[1]
falseBreakout = high > breakoutLevel and close < breakoutLevel

// NEW: Enhanced Order Book Imbalance Shields

// (Simulated since Pine can't access full L2 data)
orderBookBuyLevels = array.new_float(5)
orderBookSellLevels = array.new_float(5)

// Simulate order book levels

for i = 0 to 4
buyLevel = close * (1 - 0.001 * (i+1) * (1 + math.sin(bar_index/10+i)))
sellLevel = close * (1 + 0.001 * (i+1) * (1 + math.sin(bar_index/7+i)))
array.set(orderBookBuyLevels, i, buyLevel)
 array.set(orderBookSellLevels, i, sellLevel)

// Calculate simulated order book pressure

orderBookBuyVolume = volumeAvg * (1 + 0.5 * math.sin(bar_index/13))
orderBookSellVolume = volumeAvg * (1 + 0.5 * math.sin(bar_index/11))
orderImbalance = math.abs(orderBookBuyVolume - orderBookSellVolume) /
(orderBookBuyVolume + orderBookSellVolume) > 0.3

// NEW: Liquidity Void Protection Layers

liquidityVoidRisk = liquidityVoid ? ta.atr(14) * 2 : 0
liquidityProtectionActive = liquidityVoid and volume < volumeAvg * 0.5

// NEW: Data Obfuscation for Security

dataObfuscated = true
if dataObfuscationEnable
// In real implementation, this would encrypt/obfuscate values
// Here we just simulate it
obfuscationKey = math.sin(bar_index) * 1000
dataObfuscated := obfuscationKey != 0 // Always true in simulation

// ==========================================
// Money Printing Features
// ==========================================

// Enhanced position sizing calculation with Greeks

riskAmount = accountSize * riskPerTrade
volatilityAdjustedRisk = riskAmount / (ta.atr(14) / close * 100)

// NEW: Greek-based position sizing

greekAdjustedSize = optionDelta > 0.5 ?
math.floor(volatilityAdjustedRisk / close * math.abs(callDelta)) :
math.floor(volatilityAdjustedRisk / close * math.abs(putDelta))

positionSize = math.floor(volatilityAdjustedRisk / close)

finalPositionSize = math.min(positionSize, greekAdjustedSize)

// Auto-trailing TP with cascade levels

trailingStop = close * 0.99
if close > close[1]
trailingStop := math.max(trailingStop[1], close * 0.99)

// NEW: Profit cascade system

var float cascadeLevel1Triggered = 0.0
var float cascadeLevel2Triggered = 0.0
var float cascadeLevel3Triggered = 0.0

// ==========================================
// Execution Protocol (Extended 10-layer confirmation)
// ==========================================

// Quantum trend momentum

trendFilter = ta.ema(close, 8) > ta.ema(close, 21)

// Compilation of all signals for enhanced 10-layer system

layer1 = trendFilter
layer2 = darkPoolSignal
layer3 = impliedVol > ivTrend
layer4 = volSpikeAnticipation
layer5 = inCombatHours
layer6 = not spoofingDetection and not falseBreakout
layer7 = neuralConfirmation
layer8 = timestampValid and dataObfuscated
layer9 = putCallRatioEnable ? putCallRatio < 1.0 : true // Bullish put/call
layer10 = quantumEntanglementSignal

// NEW: Special conditions

fedSpeechOverride = fedSpeechToday and fedSpeechImpact > 0
zeroDateAdjustment = zerodateExpirationEnable and zeroDateImpact != 0

// Final buy/sell signals with enhanced criteria

buySignal = layer1 and layer2 and layer3 and layer4 and layer5 and layer6 and
layer7 and layer8 and layer9 and layer10 and
not fedSpeechOverride and
not liquidityVoidRisk and
not gammaRisk and
close > open

sellSignal = not layer1 and layer2 and layer3 and layer4 and layer5 and layer6 and
layer7 and layer8 and not layer9 and layer10 and
not fedSpeechOverride and
not liquidityVoidRisk and
not gammaRisk and
close < open

// ==========================================
// Visualization - Stealth Mode Interface
// ==========================================

// Store signals to prevent repainting

var float lastBuyPrice = na
var float lastSellPrice = na
var float stopLossLevel = na
var float takeProfitLevel = na
var float takeProfit2Level = na
var float takeProfit3Level = na

if buySignal
lastBuyPrice := close
stopLossLevel := close - baseStopLoss
takeProfitLevel := close + profitTarget1
takeProfit2Level := close + profitTarget2
takeProfit3Level := close + profitTarget3

if sellSignal
lastSellPrice := close
stopLossLevel := close + baseStopLoss
takeProfitLevel := close - profitTarget1
takeProfit2Level := close - profitTarget2
takeProfit3Level := close - profitTarget3

// Clean chart with minimal visual elements

if not na(lastBuyPrice)
box.new(bar_index, lastBuyPrice, bar_index+1, lastBuyPrice,
bgcolor=color.new(color.aqua, 70), border_color=color.aqua, border_width=2,
text="BUY " + str.tostring(lastBuyPrice, "#.##"), text_color=color.white)

if not na(lastSellPrice)
box.new(bar_index, lastSellPrice, bar_index+1, lastSellPrice,
bgcolor=color.new(color.orange, 70), border_color=color.orange, border_width=2,
text="SELL " + str.tostring(lastSellPrice, "#.##"), text_color=color.white)

if not na(stopLossLevel)
box.new(bar_index, stopLossLevel, bar_index+1, stopLossLevel,
bgcolor=color.new(color.red, 70), border_color=color.red, border_width=2, text="SL
" + str.tostring(stopLossLevel, "#.##"), text_color=color.white)

if not na(takeProfitLevel)
box.new(bar_index, takeProfitLevel, bar_index+1, takeProfitLevel,
bgcolor=color.new(color.green, 70), border_color=color.green, border_width=2,
text="TP1 " + str.tostring(takeProfitLevel, "#.##"), text_color=color.white)

if not na(takeProfit2Level)
box.new(bar_index, takeProfit2Level, bar_index+1, takeProfit2Level,
bgcolor=color.new(color.green, 80), border_color=color.green, border_width=2,
text="TP2 " + str.tostring(takeProfit2Level, "#.##"), text_color=color.white)

if not na(takeProfit3Level)
box.new(bar_index, takeProfit3Level, bar_index+1, takeProfit3Level,
bgcolor=color.new(color.green, 90), border_color=color.green, border_width=2,
text="TP3 " + str.tostring(takeProfit3Level, "#.##"), text_color=color.white)

// ==========================================
// Advanced Dashboard Table
// ==========================================

// Military-grade dashboard (right panel)

var table dashboardTable = table.new(position.right_top, columns=2, rows=18,
bgcolor=color.new(color.black, 20), border_width=1)
table.cell(dashboardTable, 0, 0, "PROJECT DARK PHOENIX",
bgcolor=color.new(color.gray, 90), text_color=color.aqua, text_size=size.small)
table.cell(dashboardTable, 1, 0, "STATUS: ACTIVE", bgcolor=color.new(color.gray,
90), text_color=color.lime, text_size=size.small)

table.cell(dashboardTable, 0, 1, "Market Phase", text_color=color.white,

bgcolor=color.new(color.gray, 90))
marketPhase = marketVolatility < 0.5 ? "Peace" : marketVolatility < 1.0 ? "War" :
"Chaos"
table.cell(dashboardTable, 1, 1, marketPhase,
text_color=marketPhase == "Peace" ? color.lime : marketPhase == "War" ?
color.orange : color.red,
bgcolor=color.new(color.gray, 90))

table.cell(dashboardTable, 0, 2, "Attack Probability", text_color=color.white,

bgcolor=color.new(color.gray, 90))
attackProbability = math.min(100,
(icebergSignal ? 30 : 0) +
(cbAlgoSignal ? 25