Code: Select all
//+------------------------------------------------------------------+
//| AUDNZD_Asian_Matrix_Pro.mq4 |
//| Institutional Liquidity & Volatility Engine |
//+------------------------------------------------------------------+
#property copyright "Institutional Microstructure Engine"
#property link ""
#property version "2.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 clrCrimson
#property indicator_color2 clrMediumSeaGreen
#property indicator_width1 2
#property indicator_width2 2
//--- Inputs
input string InpSessionTime = "22:00-06:00"; // Asian Range (Server Time)
input int InpAdrPeriod = 14; // ADR Period (Days)
input double InpMinSweepPips = 1.5; // Min Liquidity Sweep (Pips)
input double InpMinWickPercent = 35.0; // Min Rejection Wick (% of Bar)
input double InpMinRangePips = 15.0; // Min Session Range (Pips)
input double InpMaxAdrPercent = 85.0; // Max Session Range (% of ADR)
input double InpMaxSpreadCostPct = 20.0; // Max Spread as % of Distance to EQ
input color InpBoxColor = C'16,26,42'; // Session Box Color
input color InpBSLColor = clrCrimson; // BSL Level Color
input color InpSSLColor = clrMediumSeaGreen; // SSL Level Color
input color InpEQColor = clrSlateGray; // Equilibrium (50%) Color
input bool InpPopupAlerts = true; // Pop-up Alert
input bool InpPushAlerts = false; // Mobile Push Notification
//--- Buffers
double BufferShortEntry[]; // 0
double BufferLongEntry[]; // 1
double BufferStopLoss[]; // 2
double BufferTP1[]; // 3
double BufferTP2[]; // 4
string Prefix = "AZN4_";
int StartHour, StartMin, EndHour, EndMin;
double PipMultiplier;
datetime LastAlertTime = 0;
//+------------------------------------------------------------------+
//| Init |
//+------------------------------------------------------------------+
int OnInit()
{
IndicatorBuffers(5);
SetIndexBuffer(0, BufferShortEntry);
SetIndexStyle(0, DRAW_ARROW);
SetIndexArrow(0, 234);
SetIndexBuffer(1, BufferLongEntry);
SetIndexStyle(1, DRAW_ARROW);
SetIndexArrow(1, 233);
SetIndexBuffer(2, BufferStopLoss);
SetIndexBuffer(3, BufferTP1);
SetIndexBuffer(4, BufferTP2);
PipMultiplier = (Digits == 3 || Digits == 5) ? Point * 10.0 : Point;
string parts[];
if(StringSplit(InpSessionTime, '-', parts) == 2)
{
string startParts[], endParts[];
StringSplit(parts[0], ':', startParts);
StringSplit(parts[1], ':', endParts);
StartHour = (int)StringToInteger(startParts[0]);
StartMin = (ArraySize(startParts) > 1) ? (int)StringToInteger(startParts[1]) : 0;
EndHour = (int)StringToInteger(endParts[0]);
EndMin = (ArraySize(endParts) > 1) ? (int)StringToInteger(endParts[1]) : 0;
}
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Deinit |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
ObjectsDeleteAll(0, Prefix);
}
//+------------------------------------------------------------------+
//| Session Filter |
//+------------------------------------------------------------------+
bool IsInSession(datetime t)
{
MqlDateTime dt;
TimeToStruct(t, dt);
int barM = dt.hour * 60 + dt.min;
int sM = StartHour * 60 + StartMin;
int eM = EndHour * 60 + EndMin;
return (sM <= eM) ? (barM >= sM && barM < eM) : (barM >= sM || barM < eM);
}
//+------------------------------------------------------------------+
//| Main Iteration |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
if(rates_total < 100) return(0);
double adr14 = 0;
for(int d = 1; d <= InpAdrPeriod; d++)
adr14 += (iHigh(NULL, PERIOD_D1, d) - iLow(NULL, PERIOD_D1, d));
double adrPips = (adr14 / InpAdrPeriod) / PipMultiplier;
int limit = rates_total - prev_calculated;
if(limit <= 0) limit = 1;
for(int i = limit; i >= 0; i--)
{
BufferShortEntry[i] = EMPTY_VALUE;
BufferLongEntry[i] = EMPTY_VALUE;
BufferStopLoss[i] = EMPTY_VALUE;
BufferTP1[i] = EMPTY_VALUE;
BufferTP2[i] = EMPTY_VALUE;
bool inSess = IsInSession(time[i]);
int idx = i;
while(idx < rates_total - 1 && !IsInSession(time[idx])) idx++;
if(IsInSession(time[idx]))
{
datetime sEnd = time[idx];
double sH = -1.0;
double sL = 999999.0;
datetime sStart = time[idx];
while(idx < rates_total - 1 && IsInSession(time[idx]))
{
sH = MathMax(sH, high[idx]);
sL = MathMin(sL, low[idx]);
sStart = time[idx];
idx++;
}
double rangePips = (sH - sL) / PipMultiplier;
double eq = (sH + sL) / 2.0;
string dayId = TimeToString(sStart, TIME_DATE);
if(i == 0)
{
RenderGeometry(dayId, sStart, sEnd, sH, sL, eq, inSess, time[0]);
RenderHUD(rangePips, adrPips, eq);
}
if(!inSess && sH > 0 && sL < 999999.0)
{
bool validRange = (rangePips >= InpMinRangePips) &&
(rangePips <= (adrPips * (InpMaxAdrPercent / 100.0)));
if(validRange)
{
double candleRange = high[i] - low[i];
if(candleRange <= 0) continue;
double currentSpreadPips = (double)MarketInfo(_Symbol, MODE_SPREAD) * Point / PipMultiplier;
// Bearish Liquidity Rejection
double upperWick = high[i] - MathMax(open[i], close[i]);
double upperWickPct = (upperWick / candleRange) * 100.0;
double sweepAbove = (high[i] - sH) / PipMultiplier;
if(sweepAbove >= InpMinSweepPips && close[i] < sH && upperWickPct >= InpMinWickPercent)
{
double distToEQ = (close[i] - eq) / PipMultiplier;
double spreadRatio = (distToEQ > 0) ? (currentSpreadPips / distToEQ) * 100.0 : 100.0;
if(spreadRatio <= InpMaxSpreadCostPct)
{
BufferShortEntry[i] = high[i] + (5 * Point);
BufferStopLoss[i] = high[i] + (2 * PipMultiplier);
BufferTP1[i] = eq;
BufferTP2[i] = sL;
if(i == 1 && LastAlertTime != time[1])
{
SendAlert("SELL", high[i], BufferStopLoss[i], eq, rangePips);
LastAlertTime = time[1];
}
}
}
// Bullish Liquidity Rejection
double lowerWick = MathMin(open[i], close[i]) - low[i];
double lowerWickPct = (lowerWick / candleRange) * 100.0;
double sweepBelow = (sL - low[i]) / PipMultiplier;
if(sweepBelow >= InpMinSweepPips && close[i] > sL && lowerWickPct >= InpMinWickPercent)
{
double distToEQ = (eq - close[i]) / PipMultiplier;
double spreadRatio = (distToEQ > 0) ? (currentSpreadPips / distToEQ) * 100.0 : 100.0;
if(spreadRatio <= InpMaxSpreadCostPct)
{
BufferLongEntry[i] = low[i] - (5 * Point);
BufferStopLoss[i] = low[i] - (2 * PipMultiplier);
BufferTP1[i] = eq;
BufferTP2[i] = sH;
if(i == 1 && LastAlertTime != time[1])
{
SendAlert("BUY", low[i], BufferStopLoss[i], eq, rangePips);
LastAlertTime = time[1];
}
}
}
}
}
}
}
return(rates_total);
}
//+------------------------------------------------------------------+
//| Drawing Helpers |
//+------------------------------------------------------------------+
void RenderGeometry(string dayId, datetime sStart, datetime sEnd, double sH, double sL, double eq, bool inSess, datetime currT)
{
string boxName = Prefix + "BOX_" + dayId;
if(ObjectFind(0, boxName) < 0)
{
ObjectCreate(0, boxName, OBJ_RECTANGLE, 0, sStart, sH, sEnd, sL);
ObjectSetInteger(0, boxName, OBJPROP_COLOR, InpBoxColor);
ObjectSetInteger(0, boxName, OBJPROP_BGCOLOR, InpBoxColor);
ObjectSetInteger(0, boxName, OBJPROP_BACK, true);
}
else
{
ObjectSetDouble(0, boxName, OBJPROP_PRICE1, sH);
ObjectSetDouble(0, boxName, OBJPROP_PRICE2, sL);
ObjectSetInteger(0, boxName, OBJPROP_TIME2, sEnd);
}
if(!inSess)
{
SetRay(Prefix + "BSL_" + dayId, sEnd, sH, currT, sH, InpBSLColor, STYLE_DASH);
SetRay(Prefix + "SSL_" + dayId, sEnd, sL, currT, sL, InpSSLColor, STYLE_DASH);
SetRay(Prefix + "EQ_" + dayId, sEnd, eq, currT, eq, InpEQColor, STYLE_DOT);
}
}
void SetRay(string name, datetime t1, double p1, datetime t2, double p2, color clr, int style)
{
if(ObjectFind(0, name) < 0)
{
ObjectCreate(0, name, OBJ_TREND, 0, t1, p1, t2, p2);
ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
ObjectSetInteger(0, name, OBJPROP_STYLE, styleTo bring this system to an institutional and prop-firm standard, we eliminate manual session guesswork, filter out low-expectancy market noise, and structure the data so any automated execution engine (EA) can read entries, stops, and targets directly off the chart buffers.
### Core Institutional Upgrades
1. **Microstructure & Spread Gatekeeper:** The indicator continuously monitors real-time broker spread against both a hard limit (e.g., maximum 1.8 pips) and the session range. If the spread-to-range ratio erodes expected value, signals are suppressed.
2. **Tick Volume Absorption Filter:** A true institutional liquidity sweep requires absorption. The script verifies that the sweep candle’s tick volume exceeds its rolling volume moving average ($V > \text{SMA}(V, 20) \times \text{Multiplier}$), filtering out low-volume drift.
3. **Execution-Ready Buffer Matrix (5 Buffers):** Rather than just plotting visual arrows, the indicator exposes five discrete buffers via `iCustom()`:
* **Buffer 0:** Short Signal Price
* **Buffer 1:** Long Signal Price
* **Buffer 2:** Calculated Stop Loss (Sweep extreme + buffer)
* **Buffer 3:** Take Profit 1 (Range Equilibrium / 50%)
* **Buffer 4:** Take Profit 2 (Opposite Session Extreme)
4. **Structured JSON Alert Payloads:** Alerts are formatted as JSON strings, allowing seamless passthrough to webhooks, Telegram, Discord, or external Python execution servers.
---
### MQL5 Production Implementation
Save as **`AUDNZD_Asian_Liquidity_Institutional.mq5`** in `MQL5/Indicators/`.
```mql5
//+------------------------------------------------------------------+
//| AUDNZD_Asian_Liquidity_Institutional.mq5 |
//| Institutional Asian Range & Sweep Execution Engine |
//+------------------------------------------------------------------+
#property copyright "Quant Architecture"
#property version "2.00"
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots 2
//--- Plot Declarations
#property indicator_label1 "Short Execution"
#property indicator_type1 DRAW_ARROW
#property indicator_color1 clrCrimson
#property indicator_width1 2
#property indicator_label2 "Long Execution"
#property indicator_type2 DRAW_ARROW
#property indicator_color2 clrMediumSeaGreen
#property indicator_width2 2
//--- Input Parameters: Session Timing
input group "=== Session Timing (Broker Server Time) ==="
input string InpSessionWindow = "22:00-06:00"; // Asian Accumulation Window
input int InpTradeWindowEndHour= 17; // Disable signals after London/NY close hour (Server Time)
//--- Input Parameters: Microstructure & Trade Quality Filters
input group "=== Institutional Quality Filters ==="
input double InpMaxSpreadPips = 2.0; // Max Allowable Spread (Pips)
input double InpMinRangePips = 15.0; // Min Asian Range Size (Pips)
input double InpMaxRangePips = 60.0; // Max Asian Range Size (Avoid Overexpanded Days)
input bool InpRequireVolSpike = true; // Require Tick Volume Spike on Sweep Bar
input double InpVolMultiplier = 1.15; // Volume Multiplier vs SMA(20)
input double InpSLBufferPips = 2.5; // Stop Loss Buffer Beyond Sweep Wick (Pips)
//--- Input Parameters: Visuals & Notifications
input group "=== UI & Telemetry ==="
input color InpBoxColor = C'15,25,40'; // Asian Range Shading
input color InpBSLColor = clrCrimson; // Buy-Side Liquidity Ray
input color InpSSLColor = clrMediumSeaGreen; // Sell-Side Liquidity Ray
input color InpEQColor = clrDarkGray; // Equilibrium Ray (50%)
input bool InpEmitJsonAlerts = true; // Emit Structured JSON Webhook Alerts
//--- Output Buffers for EAs
double BufferShortSignal[];
double BufferLongSignal[];
double BufferCalculatedSL[];
double BufferTargetTP1[];
double BufferTargetTP2[];
//--- Internal State
string Prefix = "ALI_";
int StartH, StartM, EndH, EndM;
double PipSize;
datetime LastProcessedBar = 0;
//+------------------------------------------------------------------+
//| Custom Indicator Initialization |
//+------------------------------------------------------------------+
int OnInit()
{
SetIndexBuffer(0, BufferShortSignal, INDICATOR_DATA);
PlotIndexSetInteger(0, PLOT_ARROW, 234);
PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
SetIndexBuffer(1, BufferLongSignal, INDICATOR_DATA);
PlotIndexSetInteger(1, PLOT_ARROW, 233);
PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
// EA Trade Management Buffers
SetIndexBuffer(2, BufferCalculatedSL, INDICATOR_CALCULATIONS);
SetIndexBuffer(3, BufferTargetTP1, INDICATOR_CALCULATIONS);
SetIndexBuffer(4, BufferTargetTP2, INDICATOR_CALCULATIONS);
PipSize = (_Digits == 3 || _Digits == 5) ? _Point * 10.0 : _Point;
// Parse Session Range
string parts[];
if(StringSplit(InpSessionWindow, '-', parts) == 2)
{
string startParts[], endParts[];
StringSplit(parts[0], ':', startParts);
StringSplit(parts[1], ':', endParts);
StartH = (int)StringToInteger(startParts[0]);
StartM = (ArraySize(startParts) > 1) ? (int)StringToInteger(startParts[1]) : 0;
EndH = (int)StringToInteger(endParts[0]);
EndM = (ArraySize(endParts) > 1) ? (int)StringToInteger(endParts[1]) : 0;
}
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom Indicator Deinitialization |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
ObjectsDeleteAll(0, Prefix);
Comment("");
}
//+------------------------------------------------------------------+
//| Session Time Boundary Verifier |
//+------------------------------------------------------------------+
bool IsInAccumulation(datetime t)
{
MqlDateTime dt;
TimeToStruct(t, dt);
int barM = dt.hour * 60 + dt.min;
int startM = StartH * 60 + StartM;
int endM = EndH * 60 + EndM;
return (startM <= endM) ? (barM >= startM && barM < endM) : (barM >= startM || barM < endM);
}
//+------------------------------------------------------------------+
//| Execution Calculation Loop |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
if(rates_total < 100) return(0);
ArraySetAsSeries(time, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(close, true);
ArraySetAsSeries(tick_volume, true);
ArraySetAsSeries(spread, true);
ArraySetAsSeries(BufferShortSignal, true);
ArraySetAsSeries(BufferLongSignal, true);
ArraySetAsSeries(BufferCalculatedSL, true);
ArraySetAsSeries(BufferTargetTP1, true);
ArraySetAsSeries(BufferTargetTP2, true);
int limit = rates_total - prev_calculated;
if(limit <= 0) limit = 1;
for(int i = limit; i >= 0; i--)
{
BufferShortSignal[i] = EMPTY_VALUE;
BufferLongSignal[i] = EMPTY_VALUE;
BufferCalculatedSL[i]= EMPTY_VALUE;
BufferTargetTP1[i] = EMPTY_VALUE;
BufferTargetTP2[i] = EMPTY_VALUE;
bool inSession = IsInAccumulation(time[i]);
// Scan backward to isolate the active/prior Asian session
int cur = i;
while(cur < rates_total - 1 && !IsInAccumulation(time[cur])) cur++;
if(IsInAccumulation(time[cur]))
{
datetime sEnd = time[cur];
double sHigh = -1.0;
double sLow = 999999.0;
datetime sStart = 0;
while(cur < rates_total - 1 && IsInAccumulation(time[cur]))
{
sHigh = MathMax(sHigh, high[cur]);
sLow = MathMin(sLow, low[cur]);
sStart = time[cur];
cur++;
}
double sessionRangePips = (sHigh - sLow) / PipSize;
double sessionEQ = (sHigh + sLow) / 2.0;
string dayKey = TimeToString(sStart, TIME_DATE);
// Render UI Elements for current day
if(i == 0)
{
ManageChartGraphics(dayKey, sStart, sEnd, sHigh, sLow, sessionEQ, inSession, time[0]);
}
// Signal Detection: Closed candle during European/US hours
MqlDateTime dt;
TimeToStruct(time[i], dt);
if(!inSession && dt.hour < InpTradeWindowEndHour && sessionRangePips >= InpMinRangePips && sessionRangePips <= InpMaxRangePips)
{
// Spread Filter
double currentSpreadPips = (double)spread[i] * _Point / PipSize;
if(currentSpreadPips <= InpMaxSpreadPips)
{
// Volume Spike Verification
bool volumeConfirmed = true;
if(InpRequireVolSpike)
{
long avgVol = 0;
for(int v = 1; v <= 20; v++) avgVol += tick_volume[i + v];
avgVol /= 20;
volumeConfirmed = (tick_volume[i] >= (avgVol * InpVolMultiplier));
}
// Bearish Liquidity Rejection (BSL Swept)
if(high[i] > sHigh && close[i] < sHigh && open[i] < sHigh && volumeConfirmed)
{
BufferShortSignal[i] = high[i] + (5 * _Point);
BufferCalculatedSL[i]= high[i] + (InpSLBufferPips * PipSize);
BufferTargetTP1[i] = sessionEQ;
BufferTargetTP2[i] = sLow;
if(i == 1 && LastProcessedBar != time[1])
{
DispatchTelemetry("SELL", close[1], BufferCalculatedSL[1], BufferTargetTP1[1], BufferTargetTP2[1], currentSpreadPips);
LastProcessedBar = time[1];
}
}
// Bullish Liquidity Rejection (SSL Swept)
if(low[i] < sLow && close[i] > sLow && open[i] > sLow && volumeConfirmed)
{
BufferLongSignal[i] = low[i] - (5 * _Point);
BufferCalculatedSL[i]= low[i] - (InpSLBufferPips * PipSize);
BufferTargetTP1[i] = sessionEQ;
BufferTargetTP2[i] = sHigh;
if(i == 1 && LastProcessedBar != time[1])
{
DispatchTelemetry("BUY", close[1], BufferCalculatedSL[1], BufferTargetTP1[1], BufferTargetTP2[1], currentSpreadPips);
LastProcessedBar = time[1];
}
}
}
}
}
}
RenderTelemetryDashboard();
return(rates_total);
}
//+------------------------------------------------------------------+
//| Graphical Object Manager |
//+------------------------------------------------------------------+
void ManageChartGraphics(string dayKey, datetime sStart, datetime sEnd, double sH, double sL, double sEQ, bool inSess, datetime curTime)
{
string boxName = Prefix + "BOX_" + dayKey;
if(ObjectFind(0, boxName) < 0)
{
ObjectCreate(0, boxName, OBJ_RECTANGLE, 0, sStart, sH, sEnd, sL);
ObjectSetInteger(0, boxName, OBJPROP_COLOR, InpBoxColor);
ObjectSetInteger(0, boxName, OBJPROP_BGCOLOR, InpBoxColor);
ObjectSetInteger(0, boxName, OBJPROP_FILL, true);
ObjectSetInteger(0, boxName, OBJPROP_BACK, true);
}
else
{
ObjectSetDouble(0, boxName, OBJPROP_PRICE1, sH);
ObjectSetDouble(0, boxName, OBJPROP_PRICE2, sL);
ObjectSetInteger(0, boxName, OBJPROP_TIME2, sEnd);
}
if(!inSess)
{
SyncRay(Prefix + "BSL_" + dayKey, sEnd, sH, curTime, sH, InpBSLColor, STYLE_DASH);
SyncRay(Prefix + "SSL_" + dayKey, sEnd, sL, curTime, sL, InpSSLColor, STYLE_DASH);
SyncRay(Prefix + "EQ_" + dayKey, sEnd, sEQ, curTime, sEQ, InpEQColor, STYLE_DOT);
}
}
void SyncRay(string name, datetime t1, double p1, datetime t2, double p2, color clr, ENUM_LINE_STYLE style)
{
if(ObjectFind(0, name) < 0)
{
ObjectCreate(0, name, OBJ_TREND, 0, t1, p1, t2, p2);
ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
ObjectSetInteger(0, name, OBJPROP_STYLE, style);
ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
ObjectSetInteger(0, name, OBJPROP_RAY_RIGHT, false);
ObjectSetInteger(0, name, OBJPROP_BACK, true);
}
else
{
ObjectSetInteger(0, name, OBJPROP_TIME2, t2);
ObjectSetDouble(0, name, OBJPROP_PRICE2, p2);
}
}
//+------------------------------------------------------------------+
//| Telemetry & Webhook Dispatcher |
//+------------------------------------------------------------------+
void DispatchTelemetry(string side, double entry, double sl, double tp1, double tp2, double sprd)
{
if(!InpEmitJsonAlerts) return;
string payload = StringFormat(
"{\"event\":\"LIQUIDITY_SWEEP\",\"pair\":\"%s\",\"side\":\"%s\",\"entry\":%.5f,\"sl\":%.5f,\"tp1\":%.5f,\"tp2\":%.5f,\"spread\":%.1f,\"time\":\"%s\"}",
_Symbol, side, entry, sl, tp1, tp2, sprd, TimeToString(TimeCurrent(), TIME_SECONDS)
);
Alert(payload);
}
//+------------------------------------------------------------------+
//| Heads-Up Execution Dashboard |
//+------------------------------------------------------------------+
void RenderTelemetryDashboard()
{
MqlRates daily[];
ArraySetAsSeries(daily, true);
int copied = CopyRates(_Symbol, PERIOD_D1, 1, 14, daily);
double adrPips = 0.0;
if(copied > 0)
{
double acc = 0;
for(int i = 0; i < copied; i++) acc += (daily[i].high - daily[i].low);
adrPips = (acc / copied) / PipSize;
}
double curSpread = (double)SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) * _Point / PipSize;
string hud = "\n == AUDNZD INSTITUTIONAL MATRIX ==" +
"\n --------------------------------------" +
"\n Real-time Spread : " + DoubleToString(curSpread, 1) + " pips" + (curSpread > InpMaxSpreadPips ? " [FILTERED]" : " [NOMINAL]") +
"\n 14-Day ADR : " + DoubleToString(adrPips, 1) + " pips" +
"\n Broker Time : " + TimeToString(TimeCurrent(), TIME_SECONDS) +
"\n Engine Status : Online (Volume & Spread Gated)" +
"\n --------------------------------------";
Comment(hud);
}
