Indicators: Nema MACD

New comment
 

Nema MACD:

MACD calculated using the NEMA.

Author: Mladen Rakic

Nema MACD
Nema MACD
  • www.mql5.com
Nema MACD indicator — that calculates MACD using the NEMA. If the depth is set to 1, NEMA is equal to EMA , for depth 2 it is equal to DEMA  , for depth 3 it is equal to TEMA and so on ..., up to depth 50. For depth 1 the calculated MACD is equal to...
 

Dear Author,

How can I check full list of every MA supported please?

Thanks!

 
A. Forex:

Dear Author,

How can I check full list of every MA supported please?

Thanks!

See the description - it is explained there
 
Mladen Rakic:
See the description - it is explained there

Thanks.

Its says:


  • 1 -> EMA
  • 2 -> DEMA
  • 3 -> TEMA
  • ....
  • 10 -> DecEMA
  • ....
  • 50 -> the maximal depth calculated by this indicator
What's the number for Triangular MA please?
 
A. Forex:

Thanks.

Its says:


  • 1 -> EMA
  • 2 -> DEMA
  • 3 -> TEMA
  • ....
  • 10 -> DecEMA
  • ....
  • 50 -> the maximal depth calculated by this indicator
What's the number for Triangular MA please?

Triangular MA is not an offspring of EMA - please read the first sentence too

Triangular MA is an entirely different type of calculation

 
Mladen Rakic:

Triangular MA is not an offspring of EMA - please read the first sentence too

Triangular MA is an entirely different type of calculation

Ok :)

What are the offsprings of EMA from depth 4 to 50 please??? (excluding depth 10)

 
Don't understand why the author ignores the question. Perhaps clearer description has to be written?

Can someone post info about types of MA from depth 4 to 9, and 11 to 49? 

Or they don't exist? 

Thanks. 
 
A. Forex:
Don't understand why the author ignores the question. Perhaps clearer description has to be written?

Can someone post info about types of MA from depth 4 to 9, and 11 to 49? 

Or they don't exist? 

Thanks. 

DEMA is Double EMA, TEMA is Triple EMA, the name is based on tuple naming, so the 4th EMA will be Quadruple EMA, 5th is Penta EMA, 6th is Hexa EMA, and so on.

 

In the "Price" option, add the option to reference the closing price of the "range highest and lowest",However, the following warning appears, please do However, the following warning appears, please do not hesitate to ask for advice, thank you!

//------------------------------------------------------------------

#property copyright "© mladen, 2016, MetaQuotes Software Corp."

#property link " www.forex-tsd.com, www.mql5.com"

//------------------------------------------------------------------

#property indicator_separate_window

//#property indicator_buffers 6

#property indicator_buffers 9

#property indicator_plots 3

#property indicator_label1 "OSMA filling"

#property indicator_type1 DRAW_FILLING

#property indicator_colour1 clrLightBlue,clrPeachPuff

#property indicator_label2 "MACD"

#property indicator_type2 DRAW_COLOR_LINE

#property indicator_colour2 clrSilver,clrDodgerBlue,clrSandyBrown

#property indicator_style2 STYLE_SOLID

#property indicator_width2 3

#property indicator_label3 "MACD signal"

#property indicator_type3 DRAW_LINE

#property indicator_colour3 clrSalmon

#property indicator_style3 STYLE_DOT


//

//

clrSalmon #property indicator_colour3 // //

//

//enum enPrices


enum enPrices

{

pr_close, // Close

pr_open, // Open

pr_high, // High

pr_low, // Low

pr_median, // Median

pr_typical, // Typical

pr_weighted, // Weighted

pr_average, // Average (high+low+open+close)/4

pr_medianb, // Average median body (open+close)/2

pr_tbiased, // Trend biased price

pr_tbiased2, // Trend biased (extreme) price

pr_haclose, // Heiken ashi close

pr_haopen , // Heiken ashi open

pr_hahigh, // Heiken ashi high

pr_halow, // Heiken ashi low

pr_hamedian, // Heiken ashi median

pr_hatypical, // Heiken ashi typical

pr_haweighted, // Heiken ashi weighted

pr_haaverage, // Heiken ashi average

pr_hamedianb, // Heiken ashi median body

pr_hatbiased, // Heiken ashi trend biased price

pr_hatbiased2, // Heiken ashi trend biased (extreme) price

pr_zoneclose, // Reference to the closing price of the high and low points of the range ((pr_close-pr_lowest)/(pr_highest-pr_lowest)*100)

pr_zonehigh, // Highest point of the interval (iHighest(NULL,0,MODE_HIGH,9,0))

pr_zonelow, // Lowest point in the range (iLowest(NULL,0,MODE_LOW,9,0))

};



input ENUM_TIMEFRAMES TimeFrame = PERIOD_CURRENT; // Time frame

input int MacdFast = 12; // Fast period Fast period

input int MacdSlow = 26; // Slow period Slow period

input int MacdSignal = 9; // Signal period // Signal period

input enPrices NemaPrice = pr_close; // Price

input int NemaDepth = 1; & // NEMA depth nbsp;// NEMA depth

input bool AlertsOn = false; // Turn alerts on?

input bool AlertsOnCurrent = true; // Alert on current bar?

input bool AlertsMessage = true; // Display messageas on alerts?

input bool AlertsSound = false; // Play sound on alerts input bool AlertsSound = false; // Play sound on alerts?

input bool AlertsEmail = false; // Send email on alerts? input bool AlertsEmail = false; // Send email on alerts?

input bool AlertsNotify = false; // Send push notification on Play sound on alerts ?

input bool Interpolate = true; // Interpolate mtf data ?


// Input bool AlertsNotify = false; // Send push notification on alerts.

// Input bool Interpolate = true; // Interpolate mtf data ?

// // The mtf data will be used as the data source for the mtf data.

// //

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

double macd[],macdc[],signal[],fillu[],filld[],count[];

int _mtfHandle = INVALID_HANDLE; ENUM_TIMEFRAMES timeFrame.

#define _mtfCall iCustom(_Symbol,timeFrame,getIndicatorName(),PERIOD_CURRENT,MacdFast,MacdSlow,MacdSignal,NemaPrice,NemaDepth. AlertsOn,AlertsOnCurrent,AlertsMessage,AlertsSound,AlertsEmail,AlertsNotify)


double zonelow[],zonehigh[],zoneclose[];

int zonelow_handle; //--- Customised "interval low price" handler

int zonehigh_handle; //--- Customised "high interval" handler

int zoneclose_handle; //--- Customised "Interval Closing Price" handler


//------------------------------------------------------------------

// //--- Customised "Interval Closing Price" handler //

//------------------------------------------------------------------

//

//

//

//

//


int OnInit()

{

SetIndexBuffer(0,fillu ,INDICATOR_DATA);

SetIndexBuffer(1,filld ,INDICATOR_DATA);

SetIndexBuffer(1,filld ,INDICATOR_DATA); SetIndexBuffer(2,macd ,INDICATOR_DATA).

SetIndexBuffer(2,macdc ,INDICATOR_DATA); SetIndexBuffer(3,macdc ,INDICATOR_COLOR_INDEX);

SetIndexBuffer(3,macdc ,INDICATOR_COLOR_INDEX); SetIndexBuffer(4,signal ,INDICATOR_DATA);

SetIndexBuffer(4,signal ,INDICATOR_DATA); SetIndexBuffer(5,count ,INDICATOR_CALCULATIONS).

SetIndexBuffer(5,count ,INDICATOR_CALCULATIONS); SetIndexBuffer(6,zonelow ,INDICATOR_DATA);

SetIndexBuffer(6,zonelow,INDICATOR_DATA); SetIndexBuffer(7,zonehigh,INDICATOR_DATA);

SetIndexBuffer(7,zonehigh,INDICATOR_DATA); SetIndexBuffer(8,zoneclose,INDICATOR_DATA); timeFrame = MathMax

timeFrame = MathMax(_Period,TimeFrame);

IndicatorSetString(INDICATOR_SHORTNAME,timeFrameToString(timeFrame)+" nema macd ("+(string)MacdFast+ ", "+(string)MacdSlow+ ", "+(string)MacdSignal+", "+(string)NemaDepth+")");");

zonelow_handle = iLow(NULL,0,iLowest(NULL,0,MODE_LOW,9,0));

zonehigh_handle = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0)); zoneclose_handle = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0))

zoneclose_handle = ((pr_close-zonelow_handle)/(zonehigh_handle-zonelow_handle))*100;


return(0);

}


//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//


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

const long& tick_volume[],

const long& volume[],

const int& spread[])

{

//---Copy the indicator custom "range" value to the indicator buffer

int COPY_RATES_LOW=CopyBuffer(zonelow_handle,0,0,rates_total,zonelow); int COPY_RATES_LOW=CopyBuffer(zonelow_handle,0,0,rates_total,zonelow)

int COPY_RATES_HIGH=CopyBuffer(zonehigh_handle,0,0,rates_total,zonehigh); int COPY_RATES_HIGH=CopyBuffer(zonehigh_handle,0,0,rates_total,zonehigh);

int COPY_RATES_CLOSE=CopyBuffer(zoneclose_handle,0,0,rates_total,zoneclose);

if (Bars(_Symbol,_Period)<rates_total) return(-1);

//

//

//

//

//

if (timeFrame!=_Period)

{

double result[]; datetime currTime[],nextTime[];

if (!timeFrameCheck(timeFrame,time)) return(0);

if (_mtfHandle==INVALID_HANDLE) _mtfHandle = _mtfCall;

if (_mtfHandle==INVALID_HANDLE) return(0);

if (CopyBuffer(_mtfHandle,5,0,1,result)==-1) return(0);

//

//

//

return(0); // //

//

#define _mtfRatio PeriodSeconds(timeFrame)/PeriodSeconds(_Period)

int i,k,n,limit = MathMin(MathMax(prev_calculated-1,0),MathMax(rates_total-(int) result[0]*_mtfRatio-1,0));

for (i=limit; i<rates_total && ! _StopFlag; i++ )

{

#define _mtfCopy(_buff,_buffNo) if (CopyBuffer(_mtfHandle,_buffNo,time[i],1, result)==-1) break; _buff[i] = result[0]

_mtfCopy(fillu ,0); filld[i] = 0;

_mtfCopy(macd ,2).

_mtfCopy(macdc ,3).

_mtfCopy(signal ,4).

_mtfCopy(signal,4); _mtfCopy(zonelow,5).

_mtfCopy(zonehigh,6).

_mtfCopy(zoneclose,7).

//

//

_mtfCopy(zoneclose,7); // //

//

//

if (!Interpolate) continue; CopyTime(_Symbol, timeFrame,time[i ],1,currTime).

if (i<(rates_total-1)) { CopyTime(_ Symbol,timeFrame,time[i+1],1,nextTime); if (currTime[0]==nextTime[0]) continue; }

for(n=1; (i-n)> 0 && time[i-n] &gt ;= currTime[0]; n++) continue;

for(k=1; (i-k)>=0 && k<n; k++)

{

#define _mtfInterpolate(_buff ) _buff[i-k] = _buff[i]+(_buff[i-n]-_buff[i])*k/n

_mtfInterpolate(fillu ).

_mtfInterpolate(macd ).

_mtfInterpolate(signal).

_mtfInterpolate(signal); _mtfInterpolate(zoneclose).

_mtfInterpolate(zonehigh); _mtfInterpolate(signal); _mtfInterpolate(zoneclose); _mtfInterpolate(zonehigh)

_mtfInterpolate(zoneclose); _mtfInterpolate(zonehigh); _mtfInterpolate(zoneelow);

} & nbsp;

}

return(i);

}


//

//

//

//

//


int i=(int)MathMax(prev_calculated-1,0); for (; i<rates_total && ! _StopFlag; i++)

{

double price = getPrice(NemaPrice,open,close,high,low,i,rates_total);

macd[i] = iNema(price,MacdFast,NemaDepth,i,rates_total,0)-iNema(price,MacdSlow ,NemaDepth,i,rates_total,1);

signal[i] = iNema(macd[i],MacdSignal ,NemaDepth,i,rates_total,2);

macdc[i] = (macd[i]>signal[i]) ? 1 : (macd[i]<signal[i]) ? 2 : (i>0) ? macdc[i-1] : 0;

fillu[i] = macd[i]-signal[i];

filld[i] = 0;

}

count[rates_total-1] = MathMax(rates_total-prev_calculated+1,1);

manageAlerts(time,macdc,rates_total); return(rates_total); }

return(rates_total);

}




//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//


#define _nemaInstances 3

#define _nemaInstancesSize 51

#define _nemcInstancesSize 51

#define _nema 50

double _workNema[][_nemaInstances*_nemaInstancesSize].

double _workNemc[][ _nemcInstancesSize].


double iNema(double value, double period, int depth, int i, int bars, int instanceNo=0)

{

depth = MathMax(MathMin(depth,_nemcInstancesSize-1),1);

int cInstance = instanceNo; instanceNo *= _nemaInstancesSize;

if (ArrayRange(_workNema,0) ! = bars) ArrayResize(_workNema,bars); if (ArrayRange(_workNema,0) !

if (ArrayRange(_workNemc,0) < cInstance+1) { ArrayResize(_workNemc,cInstance+1); _workNemc[cInstance][0 ]=-1; }

if (_workNemc[cInstance][0] ! = depth)

{_workNemc[cInstance][0] = depth; for(int k=1; k<=depth; k++) _workNemc[cInstance][k] = factorial(depth)/(factorial(depth-k)*factorial(k)); }

//

//

//

//

//


_workNema[i][instanceNo+_nema] = value;

if (period>1)

{

double alpha = 2.0/(1.0+period), sign=1; _workNema[i][instanceNo+_nema] = 0;

for (int k=0; k<depth; k++, sign *= -1)

{

_workNema[i][instanceNo+k ] = (i>0) ? _workNema[i-1][instanceNo+k]+alpha*(value-_workNema[i-1][instanceNo+k]) : value; value = _workNema[i][instanceNo+k];

_workNema[i][instanceNo+_nema] += value*sign*_workNemc[cInstance][k+1];

}

}

return(_workNema[i][instanceNo+_nema]);

}

double factorial(int n) { double a=1; for(int i=1; i<=n; i++) a*=i; return(a); }



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//

//


#define priceInstances 1


double zoneLow = iLow(NULL,0,iLowest(NULL,0,MODE_LOW,9,0)); double zoneHigh = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0)); double zoneHigh = iHigh(NULL,0,MODE_HIGH,9,0))

double zoneHigh = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0)); & nbsp;

double zoneClose = ((pr_close-zoneLow)/(zoneHigh-zoneLow))*100;


double workHa[][priceInstances*4]; double getPrice(int t_close-zoneLow)/(zoneHigh-zoneLow)*100;

double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i,int _bars , int instanceNo=0)

{

if (tprice>=pr_haclose)

{

if (ArrayRange(workHa,0)! = _bars) ArrayResize(workHa,_bars); instanceNo*=4;

//

//

//

//

//

double haOpen; if (i>0)

if (i>0)

haOpen = (workHa[i-1][instanceNo+2] + workHa[i-1][instanceNo+3])/2.0;

else haOpen = (open[i]+close[i])/2;

double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;

double haHigh = MathMax(high[i], MathMax(haOpen,haClose));

double haLow = MathMin(low[i] , MathMin(haOpen,haClose)); double haLow = MathMin(low[i] , MathMin(haOpen,haClose))


if(haOpen < haClose) { workHa[i][instanceNo+0] = haLow; workHa[i][instanceNo+1] = haHigh; }& nbsp; else { workHa[i][instanceNo+1] = haHigh; }

else { workHa[i][instanceNo+0] = haHigh; workHa[i][ instanceNo+1] = haLow; }

workHa[i][instanceNo+2] = haOpen;

workHa[i][instanceNo+3] = haClose;

//

//

//

// //

//

switch (tprice)

{

case pr_haclose: return(haClose);

case pr_haclose: return(haClose); case pr_haopen: return(haOpen); case pr_hahigh: return(haHigh); case pr_haclose: return(haHigh); return(haHigh)

case pr_hahigh: return(haHigh); case pr_halow: return(haLow); return(haLow); return(haHigh)

case pr_halow: return(haLow); case pr_hamedian: return(haHigh); case pr_halow: return(haHigh)

case pr_hamedian: return((haHigh+haLow)/2.0);

case pr_hamedianb: return((haOpen+haClose)/2.0);

case pr_hatypical: return((haHigh+haLow+haClose)/3.0);

case pr_haweighted: return((haHigh+haLow+haClose+haClose)/4.0);

case pr_haaverage: return((haHigh+haLow+haClose+haOpen)/4.0);

case pr_hatbiased.

if (haClose>haOpen)

return((haHigh+haClose)/2.0); case pr_hatbiased: if (haClose>haOpen)

else return((haLow+haClose)/2.0);

case pr_hatbiased2.

if (haClose>haOpen) return(haHigh); case_hatbiased2.

if (haClose<haOpen) return(haLow); return(haClose)

return(haLow); return(haClose).

case pr_zoneclose: return(zoneClose); case pr_zonehigh: return(zoneClose); if (haClose<haOpen) return(haLow); return(haClose)

case pr_zonehigh: return(zoneHigh); case pr_zonelow: return(zoneHigh); return(zoneHigh); return(zoneHigh)

case pr_zonelow: return(zoneLow); case pr_zonelow: return(zoneLow)

}

}

//

//

//

//

//

switch (tprice)

case pr_close: return(close[i]); }

case pr_close: return(close[i]); case pr_open: return(open[i]); } }

case pr_open: return(open[i]); case pr_high: return(high[i]); // switch (tprice) { case pr_close: return(close[i]); return(open[i])

case pr_high: return(high[i]); case pr_low: return(low[i]); case pr[i])

case pr_low: return(low[i]); case pr_median: return(low[i])

case pr_median: return((high[i]+low[i])/2.0); case pr_medianb: return(high[i]+low[i])/2.0)

case pr_medianb: return((open[i]+close[i])/2.0);

case pr_typical: return((high[i]+low[i]+close[i])/3.0); case pr_weighted: return((high[i]+low[i]+close[i])/3.0)

case pr_weighted: return((high[i]+low[i]+close[i]+close[i])/4.0);

case pr_average: return((high[i]+low[i]+close[i]+open[i])/4.0);

case pr_tbiased.

if (close[i]>open[i])

return((high[i]+close[i])/2.0); case pr_tbiased.

else return((low[i]+close[i])/2.0); case pr_tbiased2: if (low[i]+close[i])/2.0)

case pr_tbiased2.

if (close[i]>open[i]) return(high[i]); case pr_tbiased2.

if (close[i]<open[i]) return(low[i]);

return(low[i]); return(close[i]) return(close[i]); return(close[i]); return(close[i])

case pr_zoneclose: return(zoneclose[i]); return(low[i]); return(close[i]); return(close[i])

case pr_zonehigh: return(zonehigh[i]); case pr_zonelow: return(zonehigh[i]); return(zonehigh[i])

case pr_zonelow: return(zonelow[i]);

}

return(0); }

}


//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//


void manageAlerts(const datetime& atime[], double& atrend[], int bars)

{

if (!AlertsOn) return; return; int whichBar = bars-1; if (!AlertsOnCurrent)

int whichBar = bars-1; if (!AlertsOnCurrent) whichBar = bars-2; datetime time1 = atime[whichBar].

if (atrend[whichBar] ! = atrend[whichBar-1])

{

if (atrend[whichBar] == 1) doAlert(time1, "up"); if (atrend[whichBar] == 1)

if (atrend[whichBar] == 2) doAlert(time1, "down");

}

}


//

//

//

//

//


void doAlert(datetime forTime, string doWhat)

{

static string previousAlert="nothing"; static datetime previousTime; static datetime forTime, string doWhat {

static datetime previousTime; static string previousAlert="nothing"; static datetime previousTime

static string previousAlert="nothing"; static datetime previousTime; string message.

if (previousAlert ! = doWhat || previousTime ! = forTime)

previousAlert = doWhat; message; if (previousAlert !

previousAlert = doWhat; previousTime = forTime; forTime

previousTime = forTime.


//

//

//

previousAlert = doWhat; previousTime = forTime; // //

//


message = timeFrameToString(_Period)+" "+_Symbol+" at "+TimeToString(TimeLocal(),TIME_SECONDS)+" nema macd state changed to "+doWhat;

if (AlertsMessage) Alert(message);

if (AlertsEmail) SendMail(_Symbol+" nema macd",message); if (AlertsNotify)

if (AlertsNotify) SendNotification(message); if (AlertsSound)

if (AlertsSound) PlaySound("alert2.wav");

}

}



//-------------------------------------------------------------------

//

//-------------------------------------------------------------------

//

//

//

//

//


string getIndicatorName()

{

string path = MQL5InfoString(MQL5_PROGRAM_PATH); string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\\MQL5\\\Indicator

string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\\MQL5\\\Indicators\\";

string name = StringSubstr(path,StringLen(data));

return(name);

}


//

//

//

//

//


int _tfsPer[]={PERIOD_M1,PERIOD_M2,PERIOD_M3,PERIOD_M4,PERIOD_M5,PERIOD_M6,PERIOD_M10,PERIOD_M12,PERIOD_M15,PERIOD_M20, PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1,PERIOD_W1,PERIOD_MN1}; string _tfsStr[]_tfsStr[]_tfsStr[]_tfsStr[]_tfsString

string _tfsStr[]={"1 minute", "2 minutes", "3 minutes", "4 minutes", "5 minutes", "6 minutes", "10 minutes", "12 minutes", "15 minutes", "20 minutes", "30 minutes", "1 hour", "2 hours", "3 hours", "4 hours", "6 hours", "8 hours", "12 hours", "daily", "weekly", "monthly"}; }

string timeFrameToString(int period)

{

if (period==PERIOD_CURRENT)

period = _Period.

int i; for(i=0;i<ArraySize(_tfsPer);i++) if (period==_tfsPer[i]) break;

return(_tfsStr[i]);

}


//

//

//

//

//


bool timeFrameCheck(ENUM_TIMEFRAMES _timeFrame,const datetime& time[])

{

static bool warned=false;

if (time[0]<SeriesInfoInteger(_Symbol,_timeFrame,SERIES_FIRSTDATE))

{

datetime startTime,testTime[];

if (SeriesInfoInteger(_Symbol,PERIOD_M1,SERIES_TERMINAL_FIRSTDATE,startTime))

if (startTime>0) { CopyTime( _Symbol,_timeFrame,time[0],1,testTime); SeriesInfoInteger(_Symbol,_timeFrame,SERIES_FIRSTDATE,startTime); }

if (startTime<=0 || startTime>time[0]) { Comment(MQL5InfoString(MQL5_PROGRAM_NAME)+"\nMissing data for "+timeFrameToString(_timeFrame)+" time frame\nRe-trying on next tick"); warned=true; return(false); }

}

if (warned) { Comment(""); warned=false; }

return(true); }

}

================================================================================================================================== ====================================

Description.

possible loss of data due to type conversion from 'double' to 'int' Nema_MACD.mq5 109 21

possible loss of data due to type conversion from 'double' to 'int' Nema_MACD.mq5 110 21
code generated

0 errors, 2 warnings, 212 msec elapsed 1 3

==================================================================================

95 int OnInit()

96 {

109 zonelow_handle = iLow(NULL,0,iLowest(NULL,0,MODE_LOW,9,0));

110 zonehigh_handle = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0));

111 zoneclose_handle = ((pr_close-zonelow_handle)/(zonehigh_handle-zonelow_handle))*100;

113 return(0);
114 }




 

Price_zoneClose

Price_zoneClose

New comment