GG_MASTER_V2

#property description  "Group Telegram: @MdShoaibkhann"

#property description "Development: - @MdShoaibkhann "
#property description "\n========== TELEGRAM_CONFIGER===================================="
#property description  "To send the bells to Telegram, call @MdShoaibkhann on Telegram"
#property description  "To get the Chat ID from the @MdShoaibkhann "
#property description "================================================================="
#define UNIQUE_SIGNAL_FILE_NAME "UniqueSignalFlag.txt"  // Unique name of the file used to track signal times
#define UNIQUE_COOLDOWN_DURATION 20
#property strict

#property indicator_chart_window
#property indicator_buffers 25

#include <WinUser32.mqh>

#import "Telegram4Mql.dll"
string TelegramSendText(string ApiKey, string ChatId, string ChatText);
string TelegramSendTextAsync(string apiKey, string chatId, string chatText);
string TelegramSendPhotoAsync(string apiKey, string chatId, string filePath, string caption = "");
#import
static int largura_tela = 0, altura_tela = 0;
#import  "Wininet.dll"
int InternetOpenW(string, int, string, string, int);
int InternetConnectW(int, string, int, string, string, int, int, int);
int HttpOpenRequestW(int, string, string, int, string, int, string, int);
int InternetOpenUrlW(int, string, string, int, int, int);
int InternetReadFile(int, uchar & arr[], int, int& OneInt[]);
int InternetCloseHandle(int);
bool HttpSendRequestW(int, string, int, string, int);
#import

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  int allowedAccountID =********;

#import "Kernel32.dll"
int GetLastError(void);
bool GetVolumeInformationW(string,string,uint,uint&[],uint,uint,string,uint);

#import

enum FontStyle { NORMAL, MONO, BOLD, ITALIC };

enum corretora_price_pro
  {
   EmTodas = 1,    //ALL
   EmIQOption = 2, //IQ Option
   EmSpectre = 3,  //Spectre
   EmBinary = 4,   //Binary
   EmGC = 5,       //Grand Capital
   EmBinomo = 6,   //Binomo
   EmOlymp = 7     //Olymp Trade
  };

enum broker
  {
   Todos = 0,   //ALL
   IQOption = 1,
   Binary = 2,
   Spectre = 3,
   Alpari = 4,
   InstaBinary = 5
  };

enum corretora
  {
   Todas = 0,   //ALL
   IQ = 1,      //IQ Option
   Bin = 2,     //Binary
   Spectree = 3,//Spectre
   GC = 4,      //Grand Capital
   Binomo = 5,  //Binomo
   Olymp = 6    //Olymp Trade
  };

enum sinal
  {
   MESMA_VELA = 0,  //SAME CANDLE
   PROXIMA_VELA = 1 //NEXT CANDLE
  };

enum tipo_expiracao
  {
   TEMPO_FIXO = 0, //Fixed Time!
   RETRACAO = 1    //Tempo Do Time Frame!
  };

enum entrar
  {
   NO_TOQUE = 0,    //DO NOT TOUCH
   FIM_DA_VELA = 1  //END OF CANDLE
  };

enum modo
  {
   MELHOR_PAYOUT = 'M', //MELHOR PAYOUT
   BINARIAS = 'B',      //BINARIAS
   DIGITAIS = 'D'       //DIGITAIS
  };

enum instrument
  {
   DoBotPro= 3, //DO BOT PRO
   Binaria= 0,  //BINARIA
   Digital = 1, //DIGITAL
   MaiorPay =2  //MAIOR PAYOUT
  };

enum signaltype
  {
   IntraBar = 0,          // SAME CANDLE
   ClosedCandle = 1       // NEXT CANDLE
  };

enum martintype
  {
   NoMartingale = 0,             // Sem Martingale (No Martingale)
   OnNextExpiry = 1,             // Next Expiry
   OnNextSignal = 2,             // Next Signal
   Anti_OnNextExpiry = 3,        // Anti-/ Next Expiry
   Anti_OnNextSignal = 4,        // Anti-/ Next Signal
   OnNextSignal_Global = 5,      // Next Signal (Global)
   Anti_OnNextSignal_Global = 6  // Anti-/ Next Signal (Global)
  };

enum FiltroEma
  {
   EMA  = 1,  // EMA
   SMMA = 2,  // SMMA
   LWMA = 3,  // LWMA
   LSMA = 4   // LSMA SMA
  };

enum intervalo
  {
   Cinco = PERIOD_M5,        // 5 MINUTOS
   Quinze = PERIOD_M15,      // 15 MINUTOS
   Trinta = PERIOD_M30,      // 30 MINUTOS
   Uma_Hora = PERIOD_H1,     // 1 HORA
  };

enum antloss
  {
   off   = 0,  //OFF
   gale1 = 1  //ENTER AFTER CANDLE
  };

enum extensaoROBO
  {
   csv   = 0,  //CSV
   txt = 1  //TXT
  };

enum automtizadores
  {
   DesligarRobo   = 0,  //OFF

   OperarComMX2 = 2,  //MX2 TRADING
   OperarComBOTPRO   = 3,  //BOTPRO
   OperarComPricePro = 4,  //PRICEPRO
   OperarComTOPWIN   = 5,  //TOPWIN V4
   OperarComTOPWIN_ATUAL   = 9,  //TOPWIN V6 (ATUAL)
   OperarComFrankestain = 6,  //RETORNO
   OperarComMT2 = 7,  //MT2
   OperarComB2IQ = 8  //B2IQ
  };

enum simnao
  {
   NAO = 0, //OFF
   SIM = 1  //ON
  };

enum tipo
  {
   DESATIVAR_PRE_ALERTA, //DISABLE
   ATIVAR_PRE_ALERTA //ACTIVATE
  };
enum UTCOffset
{
   UTCp600 = 0,         // UTC: +6:00 G.M.T
   UTCp530 = -1800,     // UTC: +5:30 G.M.T
   UTCp500 = -3600,     // UTC: +5:00 G.M.T
   UTCp430 = -5400,     // UTC: +4:30 G.M.T
   UTCp400 = -7200,     // UTC: +4:00 G.M.T
   UTCp330 = -9000,     // UTC: +3:30 G.M.T
   UTCp300 = -10800,    // UTC: +3:00 G.M.T
   UTCp200 = -14400,    // UTC: +2:00 G.M.T
   UTCp100 = -18000,    // UTC: +1:00 G.M.T
   UTC0000 = -21600,    // UTC: +0:00 G.M.T
   UTCm100 = -25200,    // UTC: -1:00 G.M.T
   UTCm200 = -28800,    // UTC: -2:00 G.M.T
   UTCm300 = -32400,    // UTC: -3:00 G.M.T
   UTCm330 = -34200,    // UTC: -3:30 G.M.T
   UTCm400 = -36000,    // UTC: -4:00 G.M.T
   UTCm500 = -39600,    // UTC: -5:00 G.M.T
   UTCm600 = -43200,    // UTC: -6:00 G.M.T
   UTCm700 = -46800,    // UTC: -7:00 G.M.T
   UTCm800 = -50400,    // UTC: -8:00 G.M.T
   UTCm900 = -54000,    // UTC: -9:00 G.M.T
   UTCm1000 = -57600,   // UTC: -10:00 G.M.T
   UTCm1100 = -61200,   // UTC: -11:00 G.M.T
   UTCm1200 = -64800    // UTC: -12:00 G.M.T
};
 enum signal
  {
   FLOW = 0,  //FLOW SIGNAL
   REVERSE = 1 //REVERSE SIGNAL
  };
enum signaltel
  {
   multiplesignal,   //Multiple Signals at a time
   singlesigna       //One signal at a time
  };

enum MVNAME1
  {
   BREAK1,  //BREAK LINE
   TOUCH1  //TOUCH LINE
  };
enum MVNAME2
  {
   BREAK2,  //BREAK LINE
   TOUCH2  //TOUCH LINE
  };
enum MVNAME3
  {
   BREAK3,  //BREAK LINE
   TOUCH3  //TOUCH LINE
  };
enum MVNAME4
  {
   BREAK4,  //BREAK LINE
   TOUCH4  //TOUCH LINE
  };
struct melhor_nivel
  {
   double            rate;
   double            value_chart_maxima;
   double            value_chart_minima;
  };
enum penel
  {
   NON_MTG = 0,  // o mtg win loss
   MTG1 = 1,         // penel 1mtg show 

  };
enum Pos
  {
   UpperLeft,
   UpperRight,
   LowerLeft,
   LowerRight
  };

enum way
  {
   BidRatio,
   OpenRatio,
   BodyRatio,
  };

datetime timet;

input string TRADE_SETTINGS_HEADER = "====== SETTINGS ======"; // Settings header title
input simnao AtivaPainel     = true;       // ACTIVE PENEL
input FontStyle FontStyleOption = MONO;    // FRONT SELECTION
input simnao  demo1     = true;             // TRAND PRADICTION 
input simnao MostrarLinha = false;         // SUPORT-REGISTANCE DROW 
input bool Volium = true;                   // MARKET VOLIUM
input penel MartingaleStep                          = 1;          //1MTG MARTINGALE STEP

input signal DirectionSignal = REVERSE;    // SIGNAL DREACTION
extern tipo Entrada          = ATIVAR_PRE_ALERTA; // PRE ALEART
input int SecEnvio           = 2;          // BEFORE SIGNAL 
input simnao ID      = false;        // AUTHONTICAR ID 

input int Velas              = 300;        // BACK TEST CANDEL
extern int VelasBack         = 100;        // (Coming soon) Backtest depth
input UTCOffset UTCCHNAGE    = UTCp600;    // TIME ZONE (UTC)

input string _________candlestrtegy_____________       = "=======| candlestrtegy |======================================================================"; //=================================================================================
input simnao candlestrtegy                            = false;   // CANDLE STRATEGY 

input string _________Reversal_STRATEGY_____________   = "=======| Reversal STRATEGY |======================================================================"; //=================================================================================
input simnao Reversal_Enabled                         = false;   // REVERSAL STRATEGY 

input string __________HUNTER_STRATEGY_____________    = "=======| HUNTER STRATEGY  |======================================================================"; //=================================================================================
input simnao HUNTER_Enabled                           = false;   // HUNTER STRATEGY 

input string _________hulk_STRATEGY_____________       = "=======|hulk STRATEGY  |======================================================================"; //=================================================================================
input simnao hulk_Enabled                              = false;   // HULK STRATEGY 

input string _________professor_STRATEGY_____________  = "=======| professor STRATEGY  |======================================================================"; //=================================================================================
input simnao professor_Enabled                         = false;   // PROFESSOR STRATEGY 

input string _________sniper_STRATEGY_____________     = "=======| sniper STRATEGY |======================================================================"; //=================================================================================
input simnao sniper_Enabled                            = false;   // SNIPER STRATEGY

input string _________ninja_STRATEGY_____________      = "=======| ninja STRATEGY |======================================================================"; //=================================================================================
input simnao ninja_Enabled                             = false;   // NINJA STRATEGY

input string _________GUNA_STRATEGY_____________       = "=======| SHADOW STRATEGY  |======================================================================"; //=================================================================================
input simnao shadow                                    = false;   // SHADOW STRATEGY

input string ___Elite_strategy_____                    = "=======| ELITE STRATEGY |======================================================================"; //=================================================================================
input simnao Elite_Enabled                             = false;   // ELITE STRATEGY

input string ________TREND_FILTER___________________         = "======= TREND_FILTER ================================================================================"; //=================================================================================
input simnao Filtro_Tendencia                            = false;   // MA TREND FILTER
input int gi_84                                           = 50;      // PERIOD
input double gd_88                                        = 0;       // SHIFT

input string _________KEN_Enabled_____________              = "=======| KEN_Enabled A |======================================================================"; //=================================================================================
input simnao KEN_Enabled                                   = false;   // KEN STRATEGY

input string _________MODOOPERACIONALRVI___________________ = "========== RVI FILTER STRATEGY =================================================================================================="; //=================================================================================
input simnao EnabledRVI                                     = false;   // RVI
input ENUM_TIMEFRAMES TimeFrame4                            = PERIOD_M1; // TIMEFRAME RVI 
input int PERIODORVI                                        = 6;       // PERIODO RVI 
input int Linha                                             = 1;       // 0 = RVI line, 1 = SIGNAL LINE
input double MAXRVI                                         = 0.1;     // MAXIMA RVI 
input double MINRVI                                         = -0.1;    // MINIMA RVI

input string _________MODOOPERACIONALMFI___________________ = "========== MFI FILTER STRATEGY =================================================================================================="; //=================================================================================
input simnao EnabledMFI                                    = false;       // MFI 
input ENUM_TIMEFRAMES TimeFrame5                           = PERIOD_M1;   // TIMEFRAME RVI 
input int PERIODOMFI                                       = 3;           // PERIODO MFI
input ENUM_APPLIED_PRICE mfiPrice                          = PRICE_CLOSE; // INPUT MODULE
input int MAXMFI                                           = 95;          // MAXIMA MFI
input int MINMFI                                           = 5;           // MINIMA MFI

input string _________MODOOPERACIONALWPR___________________ = "========== WPR FILTER STRATEGY =================================================================================================="; //=================================================================================
input simnao EnabledWPR                                     = false;       // WPR 
input ENUM_TIMEFRAMES TimeFrame6                            = PERIOD_M1;   // TIMEFRAME WPR
input int PERIODOWPR                                        = 1;           // PERIODO WPR 
input ENUM_APPLIED_PRICE wprPrice                           = PRICE_CLOSE; // INPUT MODULE
input int MAXWPR                                            = -95;         // MAXIMA WPR 
input int MINWPR                                            = -5;          // MINIMA WPR 

input string ________FILTROS____________________             = "========== ACTIVE HILL 1 FILTER =================================================================================================="; //=================================================================================
input simnao HILL                                           = false;       // HILL MODIFIER
input int RSIPeriod                                        = 9;           // PERIODRSI
input int Divisor                                           = 5;           // DIVISOR
input int DeviationPeriod                                     = 70;          // PERIODDEVIATION
input double Desvio                                         = 0.8;         // DETOUR

input string ________FILTRO____________________              = "========== ACTIVE HILL 2 FILTER =================================================================================================="; //=================================================================================
input simnao HILL1                                          = false;       // HILL MODIFIER
input int RSI1Period                                       = 9;           // PERIODRSI
input int Divisor1                                          = 5;           // DIVISOR
input int Deviation1Period                                    = 70;          // PERIODDEVIATION
input double Desvio1                                        = 0.8;         // DETOUR

input string ________FILT____________________                = "========== ACTIVE HILL 3 FILTER =================================================================================================="; //=================================================================================
input simnao HILL2                                          = false;       // HILL MODIFIER
input int RSI2Period                                       = 9;           // PERIODRSI
input int Divisor2                                          = 5;           // DIVISOR
input int Deviation2Period                                    = 70;          // PERIODDEVIATION
input double Desvio2                                        = 0.8;         // DETOUR

input string ________FI____________________                  = "========== ACTIVE HILL 4 FILTER =================================================================================================="; //=================================================================================
input simnao HILL3                                          = false;       // HILL MODIFIER
extern int RSI_8                                            = 9;
extern ENUM_APPLIED_PRICE PriceRSI                          = PRICE_CLOSE;
extern int Divisor8                                         = 5;
extern int Deviation8Period                                   = 70;
extern double Desvio8                                       = 0.8;

input string _________ESTREGIA_MASTER_____________= "======= RSI STATARGY  ======================================================================"; //=================================================================================";
input bool MasterEstrategia = false; // Enable/Disable Strategy
input int PeriodoRSI = 3;           // RSI Period
input int MaxRSI = 65;              // Overbought Level
input int MinRSI = 30;              // Oversold Level
input double LotSize = 0.1;         // Lot Size
input double StopLoss = 10;         // Stop Loss in Pips
input double TakeProfit = 20;       // Take Profit in Pips
input int MA_Period = 50;           // Moving Average Period
input int MA_Type = MODE_SMA;       // Moving Average Type

input string _________KILTENER___________________ = "================== STRATEGY 1 ==============================================================================="; //=================================================================================

enum ENUM_KC_MODE
{
    OUT_OF_LEVEL,
    TOUCH_LEVEL,
    RESPECT_LEVEL,
    ON_LEVEL_CLOSE,
    INSIDE_LEVEL,
    REVERSAL_SIGNAL,
    FAKE_BREAKOUT
};

extern simnao KeltnerChannel       = true;        // KELTNER CHANNEL
extern int KeltnerPeriod           = 20;          // KC PERIOD
extern int KCAtrPeriod             = 10;          // KC ATR PERIOD
extern double ATRMultiplier        = 2.0;         // KC ATR MULTIPLIER 
extern int Shift                   = 0;           // SHIFT
extern ENUM_KC_MODE KCMode         = TOUCH_LEVEL; // KC MODE

double MiddleBuffer[];
double UpperBuffer[];
double LowerBuffer[];

input string  _________MODOOPERACIONALST___________________ = "========== STOCHASTIC FILTER STRATEGY ==================================================================================================";//=================================================================================";
input simnao        Stochastic_Enabled2 = false; //STOCHASTIC STRATEGY
input ENUM_TIMEFRAMES    STCTimeFrame2 = PERIOD_CURRENT; //TIMEFRAME
input int                SO_KPeriod2=5; //%K PERIOD
input int                SO_DPeriod2=3; //%D PERIOD
input int                SO_Slowing2=3; //SO_SLOWING
input ENUM_MA_METHOD     SO_Mode2=MODE_SMA;//SO_MODE
input ENUM_STO_PRICE     SO_Price2=STO_CLOSECLOSE;//SO_PRICE
input int                SO_MAX2=80; //MAXIMUM LEVEL
input int                SO_MIN2=20; //MINIMUM LEVEL

input string  ________PSAR___________________ = "======= PARABOIC SAR ================================================================================";//=================================================================================";
input simnao UsePSAR = false;            // PARABOLIC SAR
input double PSAR_Step = 0.02;        // STEP VALUE
input double PSAR_Maximum = 0.2;      // MAXIMUM VALUE

input string  _________MODOOPERACIONALSTOC___________________ = "========== STOCHASTIC FILTER STRATEGY ==================================================================================================";//=================================================================================";
input simnao        Stochastic_Enabled = false; //STOCHASTIC STRATEGY
input ENUM_TIMEFRAMES    STCTimeFrame = PERIOD_CURRENT; //TIMEFRAME
input int                SO_KPeriod=5; //%K PERIOD
input int                SO_DPeriod=3; //%D PERIOD
input int                SO_Slowing=3; //SO_SLOWING
input ENUM_MA_METHOD     SO_Mode=MODE_SMA;//SO_MODE
input ENUM_STO_PRICE     SO_Price=STO_CLOSECLOSE;//SO_PRICE
input int                SO_MAX=80; //MAXIMUM LEVEL
input int                SO_MIN=20; //MINIMUM LEVEL

input string  __________movingaverage1_______________________ = "====== MOVING AVERAGE 1 ==================================================================================================";//=================================================================================";
input simnao MA1_Enabled= NAO ;     //MOVING AVERAGE#1
input int MA1_Period=20;                //PERIOD
input int MA1_Shift=0;                //SHIFT
input ENUM_MA_METHOD MA1_Method=MODE_SMA;                //METHOD   
input ENUM_APPLIED_PRICE MA1_Applied_Price= PRICE_CLOSE;       //PRICE
input ENUM_TIMEFRAMES  MA1_Timeframe=PERIOD_M1;  //TIMEFRAME
input MVNAME1 OPERATE1 =BREAK1;                   //OPERATE ON?

input string  __________movingaverage2_______________________ = "====== MOVING AVERAGE 2 ==================================================================================================";//=================================================================================";
input simnao MA2_Enabled= NAO ;     //MOVING AVERAGE#2
input int MA2_Period=40;                //PERIOD
input int MA2_Shift=0;                //SHIFT
input ENUM_MA_METHOD MA2_Method=MODE_SMA;                //METHOD   
input ENUM_APPLIED_PRICE MA2_Applied_Price= PRICE_CLOSE;       //PRICE
input ENUM_TIMEFRAMES  MA2_Timeframe=PERIOD_M1;  //TIMEFRAME
input MVNAME2 OPERATE2 =BREAK2;                   //OPERATE ON?

input string  __________movingaverage3_______________________ = "====== MOVING AVERAGE 3 ==================================================================================================";//=================================================================================";
input simnao MA3_Enabled= NAO ;     //MOVING AVERAGE#3
input int MA3_Period=80;                //PERIOD
input int MA3_Shift=0;                //SHIFT
input ENUM_MA_METHOD MA3_Method=MODE_SMA;                //METHOD   
input ENUM_APPLIED_PRICE MA3_Applied_Price= PRICE_CLOSE;       //PRICE
input ENUM_TIMEFRAMES  MA3_Timeframe=PERIOD_M1;  //TIMEFRAME
input MVNAME3 OPERATE3 =BREAK3;                   //OPERATE ON?

input string  __________movingaverage4_______________________ = "====== MOVING AVERAGE 4 ==================================================================================================";//=================================================================================";
input simnao MA4_Enabled= NAO ;     //MOVING AVERAGE#4
input int MA4_Period=140;                //PERIOD
input int MA4_Shift=0;                //SHIFT
input ENUM_MA_METHOD MA4_Method=MODE_SMA;                //METHOD   
input ENUM_APPLIED_PRICE MA4_Applied_Price= PRICE_CLOSE;       //PRICE
input ENUM_TIMEFRAMES  MA4_Timeframe=PERIOD_M1;  //TIMEFRAME
input MVNAME4 OPERATE4 =BREAK4;                   //OPERATE ON?

input string  _________OperationalEMA___________________ = "=====| EMA CROSS STRATEGY | ================================================================================";//=================================================================================";
input simnao AtivarCruzamento = false;    //EMA CROSS STRTEGY ?
input int FasterEMA = 1;                // RAPID EMA 
input int SlowerEMA = 5;                // SLOW EMA 

input string  _________MODOOPERACIONALVL___________________ = "========== VALUECHART CONF STRATEGY ==================================================================================================";//=================================================================================";
input simnao   HabilitarValueChart  = false;     // HABILITAR VALUE CHART 
input double value_chart_minima   =-5.0;             // SALES ZONES VALUE CHART
input double value_chart_maxima   = 5.0;             // VALUE CHART BUYING ZONES

input string _________CANDLE_CONFIRMATION_____________= "=======| CANDLE RESPECT |======================================================================"; //=================================================================================";
input simnao    GUNAEstrategia1               = false;  //CANDLE RESPECT(RSI+SR+CANDLE)
input int PeriodoRSI1 = 3;                             //PERIOD RSI
input int MaxRSI1 = 90;                                //MAXIMUM RSI
input int MinRSI1 = 10;                               //MINIMUM RSI

input string  _________OPERACIONAMACD___________________ = "========== MACD STRATEGY ==================================================================================================";//=================================================================================";
extern simnao MACD_Enabled = false; // MACD STRATEGY 
input int InpFastEMA=12;   // Fast EMA Period
input int InpSlowEMA=26;   // Slow EMA Period
input int InpSignalSMA=9;  // Signal SMA Period

input string  _________MODOOPERACIONALBB___________________ = "========== BANDS CONF STRATEGY ==================================================================================================";//=================================================================================";
input simnao   Bandas  = false;            // ACTIVE OPERATIONAL BANDS
input ENUM_TIMEFRAMES TimeFrame2  =  PERIOD_M1; // BANDS TIMEFRAME 
input int    BB_Period               = 20;      // BANDS PERIOD
input double BB_Dev                  = 1.5;     // BANDS DESVIATIONS
input int    BB_Shift                = 0;       // SAME CANDLE OR NEXT SIGNAL

input string  ________SeR___________________ = "======= SUPORTE E RESITENCIA ================================================================================";//=================================================================================";
input simnao  SeR                = false;  //  SUPORTE & RESISTENCIA
input int mediaMovel = 14; // MEDIA PERIOD
input int mediaMovel2 = 30; //SECOND  MEDIA PERIOD

input string  ________DONCHIAN___________________ = "======= DONCHIAN ================================================================================";//=================================================================================";
extern simnao AtivaDonchian = NAO; //ACTIVATE DONCHIAN
extern int       Periods=15; //PERIODS
extern int       Extremes=3; //EXTREMES
extern int       Margins=-2; //MARGINS
int       Advance=0; //Advance
extern int LarguraDonchian = 2; //LINE WIDTH
extern ENUM_LINE_STYLE EstiloDonChian = STYLE_SOLID; //LINE STYLE
extern color CorDonChianAcima = clrGreen; //TOP LINE COLOR
extern color CorDonChianAbaixo = clrRed; //BOTTOM LINE COLOR

input string  ________CCI___________________ = "======= CCI ================================================================================";//=================================================================================";
extern simnao Cci_Enabled  = NAO;// ACTIVATE CCI
input int                   CCI_Period               = 6;                     // PERIOD
input ENUM_APPLIED_PRICE    Apply_to                 = PRICE_TYPICAL;         // PRICE
input int                   CCI_Overbought_Level     = 160;                   // MAXIMUM LEVEL
input int                   CCI_Oversold_Level       = -160;                  //MINIMUM LEVEL

input string  ________ADX___________________ = "======= ADX ================================================================================";//=================================================================================";
extern simnao             Adx_Enabled  = NAO;                  // ACTIVATE ADX
extern int                period_adx   = 5;                  // PERIOD
extern double             level_adx    = 60.0;                 // LEVEL
extern ENUM_APPLIED_PRICE price_adx    = 0;                   // PRICE

input string  ________DON_FOREX___________________ = "======= DONFOREX ================================================================================";//=================================================================================";
input simnao ativar_donforex = false; //DONFOREX
input int min_size_donforex = 6; //MIN. AREA FOR DONFOREX SEGNAL

input string  ________FILTRO_DE_RETRACAO___________________ = "======= RETRACTION FILTER ================================================================================";//=================================================================================";
input simnao              FILT_RET_              = false;                             // Retraction FILTER
input int                ShadowRatio           =80;                               // BODY X WICK [%]

input string  __________FILTRO_DE_HORARIOS_______________________ = "====== SCHEDULE FILTER! ==================================================================================================";//=================================================================================";
input simnao           filtro_horario = false;                                //ACTIVATE TIME FILTER
input string         horario_inicio_sinais = "00:00";                     //START TIME
input string         horario_fim_sinais = "16:00";                        //END TIME
input string         horario_inicio_sinais3 = "21:00";                     //START TIME
input string         horario_fim_sinais3 = "23:59";                        //END TIME

input string  __________FILTRO_DE_NOTICIAS_______________________ = "====== NEWS_FILTER! ==================================================================================================";//=================================================================================";
input simnao           filtro_noticias = false; //ACTIVATE NEWS
input int            noticia_minutos_antes = 15;  // MIN AFTER
input int            noticia_minutos_depois = 15; // MIN AFTER
input int            noticia_impacto = 3; // IMPACT LEVEL
input simnao alerta_noticia_touros = SIM; //VIEW NEWS ALERT

input string  _________FILTRO_DE_ACERTIVIDADE___________________ = "====== ACCERTIVITY FILTER ================================================================================";//=================================================================================";
input simnao FixedHand            = false;    // APPLY FILTER NOT WINRATE
input double FixedHandFilter = 65;        // FILTER WINRATE
input simnao AplicaFiltroNoGale = false;    //APPLY FILTER NO WINRATE GALE 1
input double FiltroMartingale = 80;     // WINRATE GALE FILTER 1

input string ___________EXTERNAL_INDICATOR_1_____________= "============ COMBINER 1!  ======================================================================"; //=================================================================================";
input simnao COMBINER = false;         // ACTIVATE INDICATOR
input string IndicatorName = "";     // INDICATOR NAME 
input int IndiBufferCall = 0;        //  CALL 
input int IndiBufferPut = 1;         // PUT 
input signaltype SignalType = IntraBar;    //  ENTEY TYPE 

input string ___________EXTERNAL_INDICATOR_2_____________= "============ COMBINER 2!  ======================================================================"; //=================================================================================";
input simnao COMBINER2 = false;         // ACTIVATE INDICATOR
input string IndicatorName2 = "";     // INDICATOR NAME 
input int IndiBufferCall2= 0;        //  CALL
input int IndiBufferPut2 = 1;         //  PUT 
input signaltype SignalType2 = IntraBar;    //  ENTEY TYPE 

input string ___________EXTERNAL_INDICATOR_3_____________= "============ COMBINER 3!  ======================================================================"; //=================================================================================";
input simnao COMBINER3 = false;         // ACTIVATE INDICATOR
input string IndicatorName3 = "";     // INDICATOR NAME
input int IndiBufferCall3= 0;        //  CALL
input int IndiBufferPut3 = 1;         // PUT 
input signaltype SignalType3 = IntraBar;    //  ENTEY TYPE 

input string ___________EXTERNAL_INDICATOR_4_____________= "============ COMBINER 4!  ======================================================================"; //=================================================================================";
input simnao COMBINER4 = false;         // ACTIVATE INDICATOR
input string IndicatorName4 = "";     // INDICATOR NAME
input int IndiBufferCall4= 0;        //  CALL 
input int IndiBufferPut4 = 1;         //  PUT 
input signaltype SignalType4 = IntraBar;    //  ENTEY TYPE 

input string ___________EXTERNAL_INDICATOR_5_____________= "============ COMBINER 5!  ======================================================================"; //=================================================================================";
input simnao COMBINER5 = false;         // ACTIVATE INDICATOR
input string IndicatorName5 = "";     // INDICATOR NAME 
input int IndiBufferCall5= 0;        //  CALL 
input int IndiBufferPut5 = 1;         //  PUT 
input signaltype SignalType5 = IntraBar;    //  ENTEY TYPE

input string _________ANALYSIS___________________ = "=======ANALYSIS FILTERS! ================================================================================"; //=================================================================================

static simnao  noDellArrow_         = true; // Interval(on/off)
input int Intervalo                  = 5;  // Interval Between Orders?
input simnao   AtivarTamanhoVela    = NAO; // MINIMO PIPS
extern int MinPips                    = 400; // BLOQUEAR VELA MAIOR QUE "XX" PIPS
input simnao   AtivarTamanhoVela1   = NAO; // MAXIMO PIPS
extern int maxPips                    = 0; // BLOQUEAR VELA MENOR QUE "XX" PIPS
input simnao Bloquea                 = false; // BLOCK ENTRIES OF CANDLE OF THE SAME COLOR (gG2)
input int quantidade                  = 3; // NUMBER OF CANDLES
simnao    FiltroVelas                = false; // USE CANDLE FILTER
input simnao   AlertsMessage         = true; // SEND ALERT
antloss  Antiloss                     = true; // QUANTITY OF CANDLES TO ENTER

input string _____________ROBOS____________________      = "====== AUTOMATIZADORES ================================================================================="; //=================================================================================
bool  ModoOTC                                            = false;  // Enviar sinal em OTC?
input automtizadores UsarRobo                            = DesligarRobo; // Usar Robo Automatizador
input int    ExpiryMinute                                 = 0;      // Expiration Time (0 = AUTO)
input string SignalName_                                  = "GG_MASTER_V2"; // Nome do Sinal para os Robos (Opcional)

input string ____________MX2____________________         = "====== MX2 =================================================================================";
input tipo_expiracao TipoExpiracao                        = RETRACAO;   // Tipo De Entrada No MX2 TRADING ?

input string ____________B2IQ____________________        = "====== B2IQ =================================================================================";
input string vps                                          = ""; // IP:PORTA da VPS (caso utilize B2IQ)

input string ____________MT2____________________         = "====== MT2 =================================================================================";
input martintype MartingaleType                           = OnNextExpiry; // Martingale  (para MT2)?
input double MartingaleCoef                               = 2.3; // Coeficiente do Martingale MT2?
input int    MartingaleSteps                              = 1;  // MartinGales Pro MT2?
input double TradeAmount                                  = 2;  // Valor do Trade Pro MT2?

input string _____EXTENSAO_RETORNO____________________     = "==== RETURN FILE EXTENSION =================================================================================";
input extensaoROBO ExtensaoBot                            = csv; // Extension to write the RETURN

input string ______TELEGRAM_CONFIG____________________    = "====== SEND TELEGRAM SIGNAL PART =================================================================================";
input signaltel GLOBALINTERVAL =  multiplesignal; // GLOBAL INTERVEL 

input simnao enviar_telegram                              = false;       // SEND TELEGRAM SIGNAL
input simnao sendphoto                                    = false;       // SEND SIGNAL SCREENSHOT TO TG
input simnao sendphotor                                   = false;       // SEND RESULT SCREENSHOT TO TG
input simnao Clearimageon                                 = false;      // CLER SCREENSHOT 

string nome_sala                                          = "GG_MASTER_V2"; // NAME OF YOUR ROOM
input string apikey_                                      = "********************"; // API KEY
input string chatid                                       = "-**********"; // CHAT ID

input simnao ATpropaganda3_                               = true;       // ROOM NAME HEADER / FOOTER
input string progandaTexto3                               = "ＬＩＶＥ ＳＩＧＮＡＬ"; // SIGNAL HEADER / FOOTER

input simnao ATpropaganda_                                = true;       // TELEGRAM USER NAME
input string progandaTexto                                = "";        // ADVERTISING TEXT RESULT

input simnao ATpropaganda4_                               = true;       // TELEGRAM OWNER
input string progandaText4                                = "@MdShoaibkhann"; // TELEGRAM OWNER

input simnao ATpropaganda1_                               = true;       // TELEGRAM CONTACT INFORMATION
input string progandaTexto1                               = "";        // ADVERTISING TEXT SIGNAL

input simnao ATpropaganda2_                               = true;       // TELEGRAM CONTACT INFORMATION
input string progandaTexto2                               = "";        // ADVERTISING TEXT REGISTERED LINK

input string nome_contact                                 = "";         // CHECK CONTACT INFORMATION
input string msgWin                                       = "";         // MSG WIN
input string msgLoss                                      = "";         // MSG LOSS

input simnao mostrarResultadoFechamento                   = true;       // SHOW CHECKING RESULTS
input simnao resultados_parciais_ao_vivo                  = true;       // TOTAL WIN AND LOSS RESULTS
input int tempo_minutos_ao_vivo                           = 20;         // SEND RESULTS TIME

const string ______INDICATOR_OWNER____________________     = "OWNER = @MdShoaibkhann";

MqlDateTime timess;
string dirBot = "GG_MASTER_V2\\";
datetime temposs = TimeToStruct(TimeLocal(),timess);

string hoje = StringFormat("%d%02d%02d",timess.year,timess.mon,timess.day);
datetime dataExpiracao = int(D'09.09.2026'); // HERE YOU SELECT WHEN THE INDICATOR WILL EXPIRE

bool liberar_acesso = true;
#define READURL_BUFFER_SIZE   100
#define INTERNET_FLAG_NO_CACHE_WRITE 0x04000000

string  arquivo_estatisticas = dirBot+hoje+"_results.txt";
bool assertividade_global = true;
#define CALL 1
#define PUT -1
datetime horario_expiracao[], horario_entrada[];
string horario_entrada_local[];
double entrada[];
double fasterEMAnow, slowerEMAnow, fasterEMAprevious, slowerEMAprevious, fasterEMAafter, slowerEMAafter;
int tipo_entrada[];
datetime befTime_signal, befTime_check, befTime_telegram, befTime_alert;
datetime befTime_aovivo=TimeGMT()-10800+tempo_minutos_ao_vivo*60;

int ExpiryMinutes=ExpiryMinute == 0 ? _Period : ExpiryMinute;
string ExtensaoBots=ExtensaoBot == 0 ? "csv" : "txt";

string horario_inicio_sinais2;
string horario_fim_sinais2;

string horario_inicio_sinais4;
string horario_fim_sinais4;

int tempoIntervalo = 60;
sinal SinalEntradaMX2 = MESMA_VELA;            //Entrar na ?
corretora CorretoraMx2 = Todas;                //Corretora ?
string paridade = Symbol()=="CRYIDZbnm" ? "Crypto IDX" : Symbol();

string SignalName = SignalName_;

string apikey = apikey_;
bool noDellArrow = noDellArrow_;
bool FILT_RET = FILT_RET_;
bool ATpropaganda = ATpropaganda_;
string propagandaTexto = ATpropaganda==true ? progandaTexto : "";
bool ATpropaganda1 = ATpropaganda1_;
string propagandaTexto1 = ATpropaganda1==true ? "\n"+progandaTexto1 : "";
bool ATpropaganda2 = ATpropaganda2_;
string propagandaTexto2 = ATpropaganda2==true ? "\n"+progandaTexto2 : "";
bool ATpropaganda3 = ATpropaganda3_;
string propagandaTexto3 = ATpropaganda3==true ? "\n"+progandaTexto3 : "";
bool ATpropaganda4 = ATpropaganda4_;
string propagandaTexto4 = ATpropaganda4_==true ? "\n"+progandaText4 : "";

datetime desativar_sinais_horario;

double donforex = ativar_donforex==true ? iCustom(NULL,0,"DONFOREX",0,0) : 0;

double vcHigh[];
double vcLow[];
double vcOpen[];
double vcClose[];
int VC_NumBars =  5;
int VC_Period = 0;

int preAlerta = Entrada==ATIVAR_PRE_ALERTA ? clrWhite : clrNONE;

int mostrarSeR = MostrarLinha==true ? clrDarkOrange : clrNONE;

const bool   volumes = true;
const way    CalculationBy =BodyRatio;
const int    InpPeriod     =1;

const Pos    Position      =UpperLeft;
const int    X_Offset      =5;
const int    Y_Offset      =20;

double BullO[],BearO[],BullC[],BearC[],BullS[],BearS[],Bulli[],Beari[];
double Bull,Bear;

int PeriodoRSI_2 = 2;
int MaxiRSI_2 = 85;
int MiniRSI_2 = 15;
int PERIODOCCI_2 = 4;
int MAXCCI_2 = 100;
int MINCCI_2 = -100;

int PeriodRSI_2 = 3;
int MaxRSI_2 = 85;
int MinRSI_2 = 15;
int PeriodoRSI_3 = 5;
int MaxRSI_3 = 60;
int MinRSI_3 = 35;
int PeriodoRSI_4 = 2;
int MaxRSI_4 = 90;
int MinRSI_4 = 10;

int                   CCI3_Period               = 4;                     // Period
ENUM_APPLIED_PRICE    Apply_to3                 = PRICE_TYPICAL;         // Price
int                   CCI3_Overbought_Level     = 100;                   // Maximum Level
int                   CCI3_Oversold_Level       = -100;                  //Minimum Level
int PeriodoRSI_9 = 3;
int MaxRSI_9 = 85;
int MinRSI_9 = 15;

int PERIODOCCI0_3 = 3;
int MAXCCI_03 = 80;
int MINCCI_03 = -80;
int BB4_Period  = 20;
int BB4_Dev  = 2;
int BB4_Shift = 1;

int                RSI1_Period=2; // Period
ENUM_APPLIED_PRICE RSI1_Price=PRICE_CLOSE;
int                RSI1_MAX=90; // Maximum Level
int                RSI1_MIN=10; // Minimum Level
ENUM_TIMEFRAMES RSITimeFrame1 = PERIOD_CURRENT; //TimeFrame
int                RSI2_Period=5; // Period
ENUM_APPLIED_PRICE RSI2_Price=PRICE_CLOSE;
int                RSI2_MAX=60; // Maximum Level
int                RSI2_MIN=30; // Minimum Level
ENUM_TIMEFRAMES RSITimeFrame2 = PERIOD_CURRENT; //TimeFrame
int                RSI3_Period=3; // Period
ENUM_APPLIED_PRICE RSI3_Price=PRICE_CLOSE;
int                RSI3_MAX=85; // Maximum Level
int                RSI3_MIN=15; // Minimum Level
ENUM_TIMEFRAMES RSITimeFrame3 = PERIOD_CURRENT; //TimeFrame

bool  UseSMAFilter  = false; //Moving Average || Enable/Disable
int  MA_Shift = 0; // MA Shift
ENUM_MA_METHOD MA_Method = MODE_EMA; // Average Type
ENUM_APPLIED_PRICE    MA_Applied_Price  = PRICE_CLOSE; //Aplicar A
int FilterShift = 0; // MA Filtro Shift
int PeriodoRSI_6 = 3;
int MaxRSI_6 = 50;
int MinRSI_6 = 50;

int                   CCI5_Period               = 6;                     // Period
ENUM_APPLIED_PRICE    Apply_to5                 = PRICE_TYPICAL;         // Price
int                   CCI5_Overbought_Level     = 160;                   // Maximum Level
int                   CCI5_Oversold_Level       = -160;                  //Minimum Level
int PERIODOWPR4   = 7;
int MAXWPR4       = -10;
int MINWPR4       = -90;

int                   CCI2_Period               = 6;                     // Period
ENUM_APPLIED_PRICE    Apply_too2                 = PRICE_TYPICAL;         // Price
int                   CCI2_Overbought_Level     = 120;                   // Maximum Level
int                   CCI2_Oversold_Level       = -120;                  //Minimum Level
int PERIODORVI3   = 4; //Period
double MAXRVI3    = 0.2; //Maximum Level
double MINRVI3    = -0.2; //Minimum Level

int                   CCI6_Period               = 14;                     // Period
ENUM_APPLIED_PRICE    Apply_to6                 = PRICE_TYPICAL;         // Price
int                   CCI6_Overbought_Level     = 100;                   // Maximum Level
int                   CCI6_Oversold_Level       = -100;                  //Minimum Level
int    BB2_Period               = 15;//Period
double    BB2_Dev                  = 3;// Desvio
int    BB2_Shift                = 0;//Deslocar

string ____________BOTPRO________________ = "===== SIGNAL SETTINGS BOTPRO =================================================================================";//=================================================================================";
string NameOfSignal = SignalName;            // Nome do Sinal para BOTPRO ?
double TradeAmountBotPro = TradeAmount;
int MartingaleBotPro = MartingaleSteps;      //Coeficiente do Martingale ?
instrument Instrument = DoBotPro;            // Modalidade ?

string ___________PRICEPRO_____________= "=== SIGNAL SETTINGS PRICE PRO ================================================================================="; //=================================================================================";
corretora_price_pro PriceProCorretora = EmTodas;       //Corretora ?

string _____________B2IQ__________________ = "====== SIGNAL SETTINGS B2IQ =================================================================================";//=================================================================================";
sinal SinalEntrada = MESMA_VELA;           //Entrar na ?
modo Modalidade = MELHOR_PAYOUT;           //Modalidade ?

string ________MAGIC_TRADER______________ = "===== SIGNAL SETTINGS MAGIC  ================================================================================="; //=================================================================================";
string               NomeIndicador        = SignalName;  // Nome do Sinal ?

string _____________MT2_____________= "======= SIGNAL SETTINGS MT2 ================================================================================="; //=================================================================================";
broker Broker = Todos;    //Corretora ?

string _____________TOP_WIN__________ = "===== TOP WIN SETTINGS =============================================================================================="; //=================================================================================";
string Nome_Sinal = SignalName;             // Nome do Sinal (Opcional)
sinal Momento_Entrada = MESMA_VELA;         // Vela de entrada

double g_ibuf_96[], g_ibuf_100[], g_ibuf_104[], gda_112[], gda_116[], gda_120[], gda_124[], gda_128[], gda_132[], gd_136, gd_144, gd_152, gd_160, gd_168, gd_176, gd_184, gd_192, gd_200;
bool gi_80 = TRUE, gi_208 = FALSE, gi_212 = FALSE;

string diretorio = "History\\EURUSD.txt";
string diretorioBotCopy = dirBot+"Sinal.csv";
string diretorioFrankestain = hoje+"_retorno."+ExtensaoBots;
string terminal_data_path = TerminalInfoString(TERMINAL_DATA_PATH);

string ___________GENERAL_SETTINGS_____________= "===== GENERAL_SETTINGS ======================================================================"; //=================================================================================";
bool   AlertsSound = false;                     //Alerta Sonoro?
string  SoundFileUp          = "alert2.wav";    //Som do alerta CALL
string  SoundFileDown        = "alert2.wav";    //Som do alerta PUT
string  AlertEmailSubject    = "";              //Assunto do E-mail (vazio = desabilita).
bool    SendPushNotification = false;           //Push Notifications?

double up[];
double down[];
double CrossUp[];
double CrossDown[];
double AntilossUp[];
double AntilossDn[];
double ExtMapBuffer1[];
double ExtMapBuffer2[];
double ExtMapBuffer3[];
double bufferMediaMovel[];

int   Sig_UpCall0 = 0;
int   Sig_DnPut0 = 0;
int   Sig_DnPut1 = 0;
int   Sig_Up0 = 0;
int   Sig_Up1 = 0;
int   Sig_Dn0 = 0;
int   Sig_Dn1 = 0;
int   Sig_Up5 = 0;
int   Sig_Dn5 = 0;
datetime LastSignal;

int MAMode;
string strMAType;
double MA_Cur, MA_Prev;
datetime data;
int candlesup,candlesdn;

#import "mt2trading_library.ex4"   // Please use only library version 13.52 or higher !!!
bool mt2trading(string symbol, string direction, double amount, int expiryMinutes);
bool mt2trading(string symbol, string direction, double amount, int expiryMinutes, string signalname);
bool mt2trading(string symbol, string direction, double amount, int expiryMinutes, martintype martingaleType, int martingaleSteps, double martingaleCoef, broker myBroker, string signalName, string signalid);
int  traderesult(string signalid);
int getlbnum();
bool chartInit(int mid);
int updateGUI(bool initialized, int lbnum, string indicatorName, broker Broker, bool auto, double amount, int expiryMinutes);
int processEvent(const int id, const string& sparam, bool auto, int lbnum);
void showErrorText(int lbnum, broker Broker, string errorText);
void remove(const int reason, int lbnum, int mid);

#import "TopWinLib.ex4"
void TradeTopWin(string ativo, string direcao, int expiracao, int momento_entrada, string nomedosinal, datetime data_atual, int timeFrameGrafico);
#import

void cleanGUI();
#import

#import "Connector_Lib.ex4"
void put(const string ativo, const int periodo, const char modalidade, const int sinal_entrada, const string vps);
void call(const string ativo, const int periodo, const char modalidade, const int sinal_entrada, const string vps);
#import

#import "botpro_lib.ex4"
int botpro(string direction, int expiration, int martingale, string symbol, double value, string name, string bindig);
#import

#import "MX2Trading_library.ex4"
bool mx2trading(string par, string direcao, int expiracao, string SignalName, int Signaltipo, int TipoExpiracao, string TimeFrame, string mID, string Corretora);
#import

#import "Inter_Library.ex4"
int Magic(int time, double value, string active, string direction, double expiration_incandle, string signalname, int expiration_basic);
#import

#import "PriceProLib.ex4"
void TradePricePro(string ativo, string direcao, int expiracao, string nomedosinal, int martingales, int martingale_em, int data_atual, int corretora);
#import

#import "MambaLib.ex4"
void mambabot(string ativo, string sentidoseta, int timeframe, string NomedoSina);
#import

int lbnum = 0;
datetime sendOnce;
int  Posicao = 0;

string asset;
string signalID;
string nc_section2 = "============ ID CODE!  ======================================================================================================="; // =========================================================================================
int mID = 0;      // ID (do not change)

double win[],loss[],wg[],ht[],wg2[],ht2[],wg1,ht1,WinRate1,WinRateGale1,WinRateGale22,ht22,wg22,mb;
double Barcurrentopen,Barcurrentclose,Barcurrentopen1,Barcurrentclose1,Barcurrentopen2,Barcurrentclose2,m1,m2,lbk,wbk;
double M1stochK,M1stochD,M5stochK,M5stochD,M15stochK,M15stochD,M30stochK,M30stochD,H1stochK,H1stochD,H4stochK,H4stochD,D1stochK,D1stochD,StochK,StochD,StochKprev,StochDprev;
double MAM1,MAM5,MAM15,MAM30,MAH1,MAH4,MAD1,MAM1prev,MAM5prev,MAM15prev,MAM30prev,MAH1prev,MAH4prev,MAD1prev,MACurrent,MAPrevious;
double Spread,PSARCurrent,PSARPrev,MACDCurrent,MACDPrev,MACDSignal,MACDSignalPrev,MAXover1,MAXover2,VolumePercent,Vol,VolPrev,Bar1,Bar2,Bar3,Bar4,Bar5,Bar6,Bar7,Bar8,Bar9,Bar10;
double Bar1percent,Bar2percent,Bar3percent,Bar4percent,Bar5percent,BarsAverage1,BarsAverage2,BarsAverage3,BarsAverage4,BarsAverage5,BarsAllpercent;
int trendM1,trendM5,trendM15,trendM30,trendH1,trendH4,trendD1,PSAR,MAXoverSignal,VolValue;

string WinRate;
string WinRateGale;
string WinRateGale2;
datetime tvb1;
int tb,g;

string s[];
datetime TimeBarEntradaUp;
datetime TimeBarEntradaDn;
datetime TimeBarUp;
datetime TimeBarDn;
datetime tempoEnvioTelegram;
double Resistencia[];
double Suporte[];
string apiKey = apikey_ ;
string chatId=chatid ;
int x;
double m;
bool initgui = false;
datetime dfrom;

string terminalPath = TerminalInfoString(TERMINAL_DATA_PATH);
string filePaths = terminalPath + "\\MQL4\\Files\\" + Symbol() + "_" + IntegerToString(_Period) + "SIGNAL.png";
string filePathsResult = terminalPath + "\\MQL4\\Files\\" + Symbol() + "_" + IntegerToString(_Period) + "RESULT.png";

int OnInit()
  {
      // код доступен только после оплаты
   }

void OnDeinit(const int reason)
  {
   Comment(" ");
   ObjectsDeleteAll(0,"Text*");
   ObjectsDeleteAll(0,"Texto_*");
   ObjectsDeleteAll(0,"Linha_*");
   ObjectsDeleteAll(0, "FrameLabel*");
   ObjectsDeleteAll(0, "label*");
   ObjectDelete(0,"zexa");
   ObjectDelete(0,"Sniper");
   ObjectDelete(0,"Sniper1");
   ObjectDelete(0,"Sniper2");
   ObjectDelete(0,"Sniper3");
   ObjectDelete(0,"zexa");
   ObjectDelete(0,"Sniper");
   ObjectDelete(0,"Sniper1");
   ObjectDelete(0,"Sniper2");
   ObjectDelete(0,"Sniper3");
   ObjectDelete(0,"expiracao");
   ObjectDelete(0,"expiracao1");
   ObjectDelete(0,"modootc");
   ObjectDelete(0,"Sniper4");
   ObjectDelete(0,"Time_Remaining");
   ObjectDelete(0,"carregando");
   ObjectDelete(0,"carregando1");
   ObjectDelete(0,"carregando2");
   ObjectDelete(0,"carregando3");
   ObjectDelete(0,"carregando4");
   ObjectDelete(0,"filtrotendencia");
   ObjectDelete(0,"filtroretracao");
   ObjectDelete(0,"bloqueavelas");
   ObjectDelete(0,"carregando5");
   ObjectDelete(0,"programador");
   ObjectDelete(0,"cop1");
   ObjectDelete(0,"pul");
   ObjectDelete(0,"pulo");
   ObjectDelete(0,"pulo1");
   ObjectDelete(0,"pulo2");
   ObjectDelete(0,"pulo3");
   ObjectDelete(0,"Win");
   ObjectDelete(0,"Loss");
   ObjectDelete(0,"WinRate");
   ObjectDelete(0,"WinGale1");
   ObjectDelete(0,"WinRateGale");
   ObjectDelete(0,"Hit");
   ObjectDelete(0,"nomeFundo");
   ObjectDelete(0,"nomeFundo2");
   ObjectDelete("VolBG1");
   ObjectDelete("Text1");
   ObjectDelete("Bulls1");
   ObjectDelete("Bullish1");
   ObjectDelete("UpPer1");
   ObjectDelete("Bears1");
   ObjectDelete("Bearish1");
   ObjectDelete("DnPer1");
   ObjectDelete("COP1");

   ObjectsDeleteAll(0, "WinNON_MTG*");
   ObjectsDeleteAll(0, "LossNON_MTG*");
   ObjectsDeleteAll(0, "WinRateNON_MTG*");   
   ObjectsDeleteAll(0, "WinMTG1*");
   ObjectsDeleteAll(0, "LossMTG1*");
   ObjectsDeleteAll(0, "WinRateMTG1*");
   ObjectsDeleteAll(0, "separator*");   
   ObjectsDeleteAll(0, "WinNON_MTG*");
   ObjectsDeleteAll(0, "LossNON_MTG*");
   ObjectsDeleteAll(0, "WinRateNON_MTG*");   
   ObjectsDeleteAll(0, "WinMTG2*");
   ObjectsDeleteAll(0, "LossMTG2*");
   ObjectsDeleteAll(0, "WinRateMTG2*");  

   FileDelete(UNIQUE_SIGNAL_FILE_NAME);
  }

double calctam()
  {
   if(Digits<=3)
     {return(0.001);}
   else
      if(Digits>=4)
        {return(0.00001);}
      else
        {
         return(0);
        }
  }

bool tamanhodevela(int i)
  {
   double tamanho = calctam()*MinPips;

   if((High[i+0]-Low[i+0])<=tamanho)
     {return(true);}
   else
     {
      return(false);
     }

  }

double calctam1()
  {
   if(Digits<=3)
     {return(0.001);}
   else
      if(Digits>=4)
        {return(0.00001);}
      else
        {
         return(0);
        }
  }

bool tamanhodevela1(int i)
  {
   double tamanho = calctam1()*maxPips;

   if((High[i+0]-Low[i+0])>=tamanho)
     {return(true);}
   else
     {
      return(false);
     }

  }

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(TimeGMT()>dataExpiracao)
     {
      Alert("account not authorized Support Telegram @MdShoaibkhann");
      return(-1);
     }

   if(isNewBar())
     {
     }

   ResetLastError();

   if(MartingaleType == NoMartingale || MartingaleType == OnNextExpiry || MartingaleType == Anti_OnNextExpiry)
      signalID = IntegerToString(GetTickCount()) + IntegerToString(MathRand());   // For NoMartingale or OnNextExpiry martingale will be candle-wide unique id generated

   ArrayResize(Resistencia,0);
   ArrayResize(Suporte,0);
   ArrayResize(CrossUp,0);
   ArrayResize(CrossDown,0);

   ChartRedraw(ChartID());
   if(liberar_acesso == true)
     {

      bull_bear(rates_total,prev_calculated,time,open,high,low,close,tick_volume,volume,spread);
      filterRatio();
      for(int i=Velas; i>=0; i--)
        {
         dfrom = TimeCurrent() - 60 * 60 * 24*Velas;

         if(Time[i] > dfrom)
           {

            double up1, dn1, up2, dn2, up3, dn3, up4, dn4, up5, dn5;
            bool up_master, dn_master,up_master1, dn_master1,up_master2, dn_master2,up_master3, dn_master3,up_master4, up_hulk, dn_hulk, up_professor, dn_professor, up_ninja, dn_ninja, up_sniper, dn_sniper,
            dn_master4, fora_banda_up, up_KEN, dn_KEN, up_HUNTER, dn_HUNTER, fora_banda_dn, up_adx, alta = false, dn_adx, up_cci, dn_cci,up_MACD, dn_MACD, up_RVI, 
            dn_RVI,  up_MFI, dn_MFI, up_psar,up_sg, dn_sg,  dn_psar,  up_WPR, dn_WPR, up_Stochastic, dn_Stochastic, up_shadow_ok = false, dn_shadow_ok = false,
             up_filter_ratio = false, dn_filter_ratio = false, ser_up, ser_dn, upmv1=false,dnmv1=false,upmv2=false,dnmv2=false,upmv3=false,
             dnmv3=false,upmv4=false,dnmv4=false, up_KC = false, dn_KC = false;

         fasterEMAnow = iMA(NULL, 0, FasterEMA, 0, MODE_EMA, PRICE_CLOSE, i);
         fasterEMAprevious = iMA(NULL, 0, FasterEMA, 0, MODE_EMA, PRICE_OPEN, i);
         fasterEMAafter = iMA(NULL, 0, FasterEMA, 0, MODE_EMA, PRICE_CLOSE, i);

         slowerEMAnow = iMA(NULL, 0, SlowerEMA, 0, MODE_EMA, PRICE_CLOSE, i);
         slowerEMAprevious = iMA(NULL, 0, SlowerEMA, 0, MODE_EMA, PRICE_OPEN, i);
         slowerEMAafter = iMA(NULL, 0, SlowerEMA, 0, MODE_EMA, PRICE_CLOSE, i);

            double ema1 = iMA(NULL, 0, mediaMovel, 0, MODE_LWMA, PRICE_HIGH,i);
            double ema2 = iMA(NULL, 0, mediaMovel, 0, MODE_LWMA, PRICE_LOW,i);
            double CCI_2 = iCCI(NULL,_Period,PERIODOCCI_2,PRICE_TYPICAL,i+1);
            double RSI_5 = iRSI(Symbol(),Period(),2,PRICE_CLOSE,i);
            double CCI_4 = iCCI(NULL,_Period,PERIODOCCI0_3,PRICE_TYPICAL,i);
            double RSI_2 = iRSI(Symbol(),Period(),2,PRICE_CLOSE,i);
            double RSI_3 = iRSI(Symbol(),Period(),2,PRICE_CLOSE,i);
            double RSI_4 = iRSI(Symbol(),Period(),2,PRICE_CLOSE,i);
            double RSI_6 = iRSI(Symbol(),Period(),2,PRICE_CLOSE,i);
            double MA_1 =iMA(NULL,0,20,0,MODE_SMMA,PRICE_CLOSE,i);
            double CCI_10   = iCCI(NULL,PERIOD_CURRENT,CCI5_Period,Apply_to5,i);
            double CCI_11   = iCCI(NULL,PERIOD_CURRENT,CCI6_Period,Apply_to6,i);
            double WPR_4 = iWPR(Symbol(),Period(),PERIODOWPR4,i);

           double PadraoVelas = (Open[i+1] + High[i+0] + Low[i+0] + Close[i+2]) / 4.0;
            double CCI_8   = iCCI(NULL,PERIOD_CURRENT,CCI3_Period,Apply_to3,i);
            double RSI_9 = iRSI(Symbol(),Period(),2,PRICE_CLOSE,i);

            double CCI_7   = iCCI(NULL,PERIOD_CURRENT,CCI2_Period,Apply_too2,i);
            double RVI_4 = iRVI(Symbol(),Period(),PERIODORVI3,0,i);

            double velas = (Open[i] + High[i] + Low[i] + Close[i]) / 4;

            double fractal1 = iFractals(NULL, 0, MODE_UPPER, i);
            if(fractal1 > 0 && velas > ema1)
               Resistencia[i] = High[i];
            else
               Resistencia[i] = Resistencia[i+1];

            double fractal2 = iFractals(NULL, 0, MODE_LOWER, i);
            if(fractal2 > 0 && velas < ema2)
               Suporte[i] = Low[i];
            else
               Suporte[i] = Suporte[i+1];

            ser_up = (!SeR || (SeR && (Low[i] <= Suporte[i] && Open[i] >= Close[i]) && (High[i+1]>= Suporte[i+1])));  //Suporte e Resistencia // LOW
            ser_dn = (!SeR || (SeR && (High[i]>= Resistencia[i] && Open[i] <= Close[i]) && (Low[i+1] <= Resistencia[i+1])));  //Suporte e Resistencia // HIGHT

            if(AtivaDonchian)
              {

               double smin=0, smax=0, SsMax=0, SsMin=0;

               if(Extremes ==1)
                 {
                  SsMax = High[Highest(NULL,0,MODE_HIGH,Periods,i)];
                  SsMin = Low[Lowest(NULL,0,MODE_LOW,Periods,i)];
                 }
               else
                  if(Extremes == 3)
                    {
                     SsMax = (Open[Highest(NULL,0,MODE_OPEN,Periods,i)]+High[Highest(NULL,0,MODE_HIGH,Periods,i)])/2;
                     SsMin = (Open[Lowest(NULL,0,MODE_OPEN,Periods,i)]+Low[Lowest(NULL,0,MODE_LOW,Periods,i)])/2;
                    }
                  else
                    {
                     SsMax = Open[Highest(NULL,0,MODE_OPEN,Periods,i)];
                     SsMin = Open[Lowest(NULL,0,MODE_OPEN,Periods,i)];
                    }

               smin = SsMin+(SsMax-SsMin)*Margins/100;
               smax = SsMax-(SsMax-SsMin)*Margins/100;
               ExtMapBuffer1[i-Advance]=smin;
               ExtMapBuffer2[i-Advance]=smax;

               if(Close[i] < smin && !alta)
                 {
                  alta = true;
                  fora_banda_up = true;
                 }
               else
                 {
                  fora_banda_up = false;
                 }

               if(Close[i] > smax && alta)
                 {
                  alta = false;
                  fora_banda_dn = true;
                 }
               else
                 {
                  fora_banda_dn = false;
                 }
              }
            else
              {
               fora_banda_up = true;
               fora_banda_dn = true;
              }

         double Maxima = (iOpen(NULL,0,iHighest(NULL,0,MODE_OPEN,AtivaDonchian,i))+iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,AtivaDonchian,i)))/2;
         double Minima = (iOpen(NULL,0,iLowest(NULL,0,MODE_OPEN,AtivaDonchian,i))+iLow(NULL,0,iLowest(NULL,0,MODE_LOW,AtivaDonchian,i)))/2;
         Maxima=Maxima-(Maxima-Minima)*-2/100;
         Minima=Minima+(Minima-Maxima)*-2/100;

         double maximaEma = iMA(NULL, 0, 14, 1, MODE_EMA, PRICE_HIGH,i);
         double minimaEma = iMA(NULL, 0, 14, 1, MODE_EMA, PRICE_LOW,i);

if (KeltnerChannel )
{
    double MiddleLine = iMA(NULL, 0, KeltnerPeriod, 0, MODE_EMA, PRICE_CLOSE, i);
    double ATR = iATR(NULL, 0, KCAtrPeriod, i);

    if (ATR > 0)
    {
        double UpperLine = MiddleLine + (ATRMultiplier * ATR);
        double LowerLine = MiddleLine - (ATRMultiplier * ATR);

        MiddleBuffer[i] = MiddleLine;
        UpperBuffer[i] = UpperLine;
        LowerBuffer[i] = LowerLine;

        up_KC = Close[i] < LowerLine;
        dn_KC = Close[i] > UpperLine;

        switch(KCMode)
        {
            case OUT_OF_LEVEL:
                up_KC = (Close[i] > UpperLine);
                dn_KC = (Close[i] < LowerLine);
                break;

            case TOUCH_LEVEL:
                up_KC = (High[i] >= UpperLine);
                dn_KC = (Low[i] <= LowerLine);
                break;

            case RESPECT_LEVEL:
                up_KC = (Low[i] >= UpperLine);
                dn_KC = (High[i] <= LowerLine);
                break;

            case ON_LEVEL_CLOSE:
                up_KC = (Close[i] > UpperLine && Close[i-1] <= UpperLine);
                dn_KC = (Close[i] < LowerLine && Close[i-1] >= LowerLine);
                break;

            case INSIDE_LEVEL:
                up_KC = (Close[i] < UpperLine && Close[i] > LowerLine);
                dn_KC = (Close[i] > UpperLine || Close[i] < LowerLine);
                break;

             case REVERSAL_SIGNAL:
                if (i > 1)
                {
                    up_KC = (Close[i] < UpperLine && Close[i-1] > UpperLine);
                    dn_KC = (Close[i] > LowerLine && Close[i-1] < LowerLine);
                }
                break;

                           case FAKE_BREAKOUT:
                if (i > 1)
                {
                    up_KC = (Close[i] < UpperLine && Close[i-1] > UpperLine);
                    dn_KC = (Close[i] > LowerLine && Close[i-1] < LowerLine);
                }
                break;   

        }
    }
}
else
{
    up_KC = true;
    dn_KC = true;
}   

         if(sniper_Enabled)
           {
            up_sniper  = CCI_10<CCI5_Oversold_Level && WPR_4<=MINWPR4;
            dn_sniper  = CCI_10>CCI5_Overbought_Level && WPR_4>=MINWPR4;
           }
         else
           {
            up_sniper = true;
            dn_sniper = true;
           }

         if(ninja_Enabled)
           {
            up_ninja = iRSI(NULL, RSITimeFrame1, RSI1_Period, RSI1_Price, i) < RSI1_MIN
                      && iRSI(NULL, RSITimeFrame2, RSI2_Period, RSI2_Price, i) < RSI2_MIN
                      && iRSI(NULL, RSITimeFrame3, RSI3_Period, RSI3_Price, i) < RSI3_MIN
                      ;
            dn_ninja = iRSI(NULL, RSITimeFrame1, RSI1_Period, RSI1_Price, i) > RSI1_MAX
                      && iRSI(NULL, RSITimeFrame2, RSI2_Period, RSI2_Price, i) > RSI2_MAX
                      && iRSI(NULL, RSITimeFrame3, RSI3_Period, RSI3_Price, i) > RSI3_MAX

                      ;
           }
         else
           {
            up_ninja = true;
            dn_ninja = true;
           }

         if(professor_Enabled)
           {
            up_professor = CCI_8<CCI3_Oversold_Level && RSI_9<=MinRSI_9 ;
            dn_professor =   CCI_8>CCI3_Overbought_Level && RSI_9>=MaxRSI_9 ;
           }
         else
           {
            up_professor = true;
            dn_professor = true;
           }

         double MA = iMA(NULL,PERIOD_CURRENT,MA_Period,MA_Shift,MA_Method,MA_Applied_Price,i+FilterShift);
         double RVI_2 = iRVI(Symbol(),Period(),PERIODORVI,0,i);//0 = Linha do RVI, 1 = Linha de sinal

         fasterEMAnow = iMA(NULL, 0, FasterEMA, 0, MODE_EMA, PRICE_TYPICAL, i);
         fasterEMAprevious = iMA(NULL, 0, FasterEMA, 0, MODE_EMA, PRICE_TYPICAL, i+1);
         fasterEMAafter = iMA(NULL, 0, FasterEMA, 0, MODE_EMA, PRICE_TYPICAL, i-1);

         slowerEMAnow = iMA(NULL, 0, SlowerEMA, 0, MODE_EMA, PRICE_TYPICAL, i);
         slowerEMAprevious = iMA(NULL, 0, SlowerEMA, 0, MODE_EMA, PRICE_TYPICAL, i+1);
         slowerEMAafter = iMA(NULL, 0, SlowerEMA, 0, MODE_EMA, PRICE_TYPICAL, i-1);

         if(hulk_Enabled)
           {
            up_hulk = CCI_7<CCI2_Oversold_Level && RVI_4<=MINRVI3 ;
            dn_hulk =   CCI_7>CCI2_Overbought_Level && RVI_4>=MAXRVI3 ;
           }
         else
           {
            up_hulk = true;
            dn_hulk = true;
           }

         if(HUNTER_Enabled)
           {
            up_HUNTER = Close[i+0]<iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_LOWER,i+0)
                      && Open[i+0]>iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_LOWER,i+0)
                      && Open[i+1]>iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_LOWER,i+1)
                      && Close[i+1]>iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_LOWER,i+1)
                      && (CCI_4<MAXCCI_03 && RSI_5<=MaxRSI_2);

            dn_HUNTER =  Close[i+0]>iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_UPPER,i+0)
                       && Open[i+0]<iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_UPPER,i+0)
                       && Open[i+1]<iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_UPPER,i+1)
                       && Close[i+1]<iBands(NULL,PERIOD_CURRENT,BB4_Period,BB4_Dev,BB4_Shift,0,MODE_UPPER,i+1)
                       && (CCI_4>MINCCI_03 && RSI_5>=MinRSI_2);

           }
         else
           {
            up_HUNTER = true;
            dn_HUNTER = true;
           }

            if(Cci_Enabled)
              {
               double CCI   = iCCI(NULL,PERIOD_CURRENT,CCI_Period,Apply_to,i);
               up_cci  = CCI<CCI_Oversold_Level;
               dn_cci  = CCI>CCI_Overbought_Level;
              }
            else
              {
               up_cci = true;
               dn_cci = true;
              }

         if(KEN_Enabled){
            up_KEN = (CCI_2>MINCCI_2 && RSI_2<=MinRSI );
            dn_KEN = (CCI_2<MAXCCI_2 && RSI_2>=MaxRSI);
            } else 
            { 
            up_KEN = true;
            dn_KEN = true;
            }

          if(Reversal_Enabled){
            up_sg =  RSI_2<=MinRSI_2 && RSI_3<=MinRSI_3 && RSI_4<=MinRSI_4 ;
            dn_sg =  RSI_2>=MaxRSI_2 && RSI_3>=MinRSI_3 && RSI_4>=MinRSI_4  ;
            } else 
            { 
            up_sg = true;
            dn_sg = true;
            }  

if (UsePSAR) 
   {
      up_psar = (Close[i] > iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i) &&
                 Open[i] > iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i) &&
                 Close[i + 1] > iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i + 1) &&
                 Open[i + 1] > iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i + 1));

      dn_psar = (Close[i] < iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i) &&
                 Open[i] < iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i) &&
                 Close[i + 1] < iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i + 1) &&
                 Open[i + 1] < iSAR(NULL, PERIOD_CURRENT, PSAR_Step, PSAR_Maximum, i + 1));
   } 
   else 
   {
      up_psar = true;
      dn_psar = true;
   }

            if(Stochastic_Enabled)
              {
               double Stochastic = iStochastic(NULL, STCTimeFrame, SO_KPeriod, SO_DPeriod, SO_Slowing, SO_Mode, SO_Price, MODE_SIGNAL, i);

               up_Stochastic  = Stochastic<SO_MIN;
               dn_Stochastic  = Stochastic>SO_MAX;
              }
            else

              {
               up_Stochastic = true;
               dn_Stochastic = true;
              }    

            if(Stochastic_Enabled2)
              {
               double Stochastic = iStochastic(NULL, STCTimeFrame, SO_KPeriod, SO_DPeriod, SO_Slowing, SO_Mode, SO_Price, MODE_SIGNAL, i);

               up_Stochastic  = Stochastic<SO_MIN;
               dn_Stochastic  = Stochastic>SO_MAX;
              }
            else
              {
               up_Stochastic = true;
               dn_Stochastic = true;
              }    

               if(EnabledRVI)
               {
                 double RVI = iRVI(Symbol(),Period(),PERIODORVI*(TimeFrame4/_Period),Linha,i+1);
                 up_RVI  = RVI<MINRVI;
                 dn_RVI  = RVI>MAXRVI;
                }
                else
              {
               up_RVI = true;
               dn_RVI = true;
              }

               if(EnabledRVI)
                  {
                     double MFI = iMFI(Symbol(),Period(),PERIODOMFI*(TimeFrame5/_Period),i+mfiPrice);
                     up_MFI  = MFI<=MINMFI;
                     dn_MFI  = MFI>MAXMFI;
                    }
               else
              {
               up_MFI = true;
               dn_MFI = true;
              }

               if(EnabledWPR)
                   {
                     double WPR = iWPR(Symbol(),Period(),PERIODOWPR*(TimeFrame6/_Period),i+wprPrice);
                     up_WPR  = WPR>=MINWPR;
                     dn_WPR  = WPR<MAXWPR;
                    }
                  else
                     {
                      up_WPR = true;
                      dn_WPR = true;
                       }

            if(Adx_Enabled)
              {
               double ADX = iADX(NULL,0,period_adx,price_adx,MODE_MAIN, i);
               up_adx  = (ADX<=level_adx);
               dn_adx  = (ADX>=level_adx);
              }
            else
              {
               up_adx = true;
               dn_adx = true;
              }

            if(MasterEstrategia)
              {
               double RSI_1 = iRSI(Symbol(),Period(),PeriodoRSI,PRICE_OPEN,i);

               if(Low[i+0] <= Suporte[i+0] && Open[i] > Close[i]
                  && ser_up //Suporte e Resistencia
                  && (RSI_1<=MinRSI))

                  up_master = true;
               else
                  up_master = false;

               if(High[i+0]>= Resistencia[i+0] && Open[i] < Close[i]
                  && ser_dn  //Suporte e Resistencia
                  && (RSI_1>=MaxRSI))

                  dn_master = true;
               else
                  dn_master = false;

              }
            else
              {
               up_master = true;
               dn_master = true;
              }

            if(Filtro_Tendencia)
              {
               if(g_ibuf_100[i+1] !=EMPTY_VALUE)   //RED
                 {
                  up_filter_ratio = true;
                 }
               else
                  if(g_ibuf_104[i+1] !=EMPTY_VALUE)   //GREEN
                    {
                     dn_filter_ratio = true;
                    }
              }
            else
              {
               up_filter_ratio = true;
               dn_filter_ratio = true;
              }

                   if(HILL3)
              {
               double HILL_3 = iRSI(Symbol(),Period(),RSIPeriod,PriceRSI,i);

               if(Low[i+0] <= Suporte[i+0] && Open[i] > Close[i]
                  && ser_up //Suporte e Resistencia
                  && (HILL_3<=MinRSI))

                  up_master = true;
               else
                  up_master = false;

               if(High[i+0]>= Resistencia[i+0] && Open[i] < Close[i]
                  && ser_dn  //Suporte e Resistencia
                  && (HILL_3>=MaxRSI))

                  dn_master = true;
               else
                  dn_master = false;

              }
            else
              {
               up_master1 = true;
               dn_master1 = true;
              }

                   if(HILL)
              {
               double HILL_3 = iRSI(Symbol(),Period(),RSIPeriod,PriceRSI,i);

               if(Low[i+0] <= Suporte[i+0] && Open[i] > Close[i]
                  && ser_up //Suporte e Resistencia
                  && (HILL_3<=MinRSI))

                  up_master = true;
               else
                  up_master = false;

               if(High[i+0]>= Resistencia[i+0] && Open[i] < Close[i]
                  && ser_dn  //Suporte e Resistencia
                  && (HILL_3>=MaxRSI))

                  dn_master = true;
               else
                  dn_master = false;

              }
            else
              {
               up_master4 = true;
               dn_master4 = true;
              }

                   if(HILL1)
              {
               double HILL_3 = iRSI(Symbol(),Period(),RSIPeriod,PriceRSI,i);

               if(Low[i+0] <= Suporte[i+0] && Open[i] > Close[i]
                  && ser_up //Suporte e Resistencia
                  && (HILL_3<=MinRSI))

                  up_master = true;
               else
                  up_master = false;

               if(High[i+0]>= Resistencia[i+0] && Open[i] < Close[i]
                  && ser_dn  //Suporte e Resistencia
                  && (HILL_3>=MaxRSI))

                  dn_master = true;
               else
                  dn_master = false;

              }
            else
              {
               up_master2 = true;
               dn_master2 = true;
              }

                   if(HILL2)
              {
               double HILL_3 = iRSI(Symbol(),Period(),RSIPeriod,PriceRSI,i);

               if(Low[i+0] <= Suporte[i+0] && Open[i] > Close[i]
                  && ser_up //Suporte e Resistencia
                  && (HILL_3<=MinRSI))

                  up_master = true;
               else
                  up_master = false;

               if(High[i+0]>= Resistencia[i+0] && Open[i] < Close[i]
                  && ser_dn  //Suporte e Resistencia
                  && (HILL_3>=MaxRSI))

                  dn_master = true;
               else
                  dn_master = false;

              }
            else
              {
               up_master3 = true;
               dn_master3 = true;
              }

            if(FILT_RET)
              {
               if(Close[i] > Open[i])
                  dn_shadow_ok = (Close[i] - Open[i])/((High[i] - Open[i])+0.0000001) > ((double)ShadowRatio)/100;

               else
                  up_shadow_ok = (Open[i] - Close[i])/((Open[i] - Low[i])+0.0000001) > ((double)ShadowRatio)/100;
              }
            else
              {
               up_shadow_ok = true;
               dn_shadow_ok = true;
              }

       if( MACD_Enabled)
              {
               double  MACD  =iMA(NULL,0,InpFastEMA,0,MODE_EMA,PRICE_CLOSE,i)-
                                       iMA(NULL,0,InpSlowEMA,0,MODE_EMA,PRICE_CLOSE,i);

               up_MACD  =  MACD<CCI_Oversold_Level;
               dn_MACD  =  MACD>CCI_Overbought_Level;
              }
            else
              {
               up_MACD = true;
               dn_MACD = true;
              }

            if(MA1_Enabled){
            double EMA123 = iMA(_Symbol, MA1_Timeframe, MA1_Period, MA1_Shift, MA1_Method, MA1_Applied_Price,MA1_Shift+ i); // Check Shift logic

           if(OPERATE1==BREAK1){
           if(Close[i] > EMA123 && Open[i] < EMA123){
             upmv1 = true;
            }
           else{
            upmv1 = false;
              }

           if(Close[i] < EMA123 && Open[i] > EMA123){
             dnmv1 = true;
            }
         else{
           dnmv1 = false;
          }
         }
   else
    if(OPERATE1==TOUCH1){
      if(Close[i] > EMA123 && Open[i] > EMA123 && Low[i] < EMA123){
         upmv1 = true;
      }
      else{
         upmv1 = false;
      }

      if(Close[i] < EMA123 && Open[i] < EMA123&& High[i] > EMA123){  // Corrected condition
         dnmv1 = true;
      }
      else{
         dnmv1 = false;
      }
   }
}
else
{
upmv1=true;
dnmv1=true;
}

        if(MA2_Enabled){
        double EMA223= iMA(_Symbol, MA2_Timeframe, MA2_Period, MA2_Shift, MA2_Method, MA2_Applied_Price,MA2_Shift+ i); // Check Shift logic

       if(OPERATE2==BREAK2){
      if(Close[i] > EMA223 && Open[i] < EMA223){
         upmv2 = true;
      }
      else{
         upmv2= false;
      }

      if(Close[i] < EMA223 && Open[i] > EMA223){
         dnmv2 = true;
      }
      else{
         dnmv2 = false;
      }
   }
   else
    if(OPERATE2==TOUCH2){
      if(Close[i] > EMA223 && Open[i] > EMA223 && Low[i] < EMA223){
         upmv2 = true;
      }
      else{
         upmv2 = false;
      }

      if(Close[i] < EMA223 && Open[i] < EMA223 && High[i] > EMA223){  // Corrected condition
         dnmv2 = true;
      }
      else{
         dnmv2= false;
      }
   }
}
else
{
upmv2=true;
dnmv2=true;
}

              if(MA3_Enabled){
   double EMA323 = iMA(_Symbol, MA3_Timeframe, MA3_Period, MA3_Shift, MA3_Method, MA3_Applied_Price,MA3_Shift+ i); // Check Shift logic

   if(OPERATE3==BREAK3){
      if(Close[i] > EMA323 && Open[i] < EMA323){
         upmv3 = true;
      }
      else{
         upmv3 = false;
      }

      if(Close[i] < EMA323 && Open[i] > EMA323){
         dnmv3 = true;
      }
      else{
         dnmv3 = false;
      }
   }
   else
    if(OPERATE3==TOUCH3){
      if(Close[i] > EMA323 && Open[i] > EMA323 && Low[i] < EMA323){
         upmv3 = true;
      }
      else{
         upmv3 = false;
      }

      if(Close[i] < EMA323 && Open[i] < EMA323 && High[i] > EMA323){  // Corrected condition
         dnmv3 = true;
      }
      else{
         dnmv3 = false;
      }
   }
}
else
{
upmv3=true;
dnmv3=true;
}

              if(MA4_Enabled){
 double   EMA423 = iMA(_Symbol, MA4_Timeframe, MA4_Period, MA4_Shift, MA4_Method, MA4_Applied_Price,MA4_Shift+ i); // Check Shift logic

   if(OPERATE4==BREAK4){
      if(Close[i] > EMA423 && Open[i] < EMA423){
         upmv4 = true;
      }
      else{
         upmv4 = false;
      }

      if(Close[i] < EMA423 && Open[i] > EMA423){
         dnmv4 = true;
      }
      else{
         dnmv4 = false;
      }
   }
   else
    if(OPERATE4==TOUCH4){
      if(Close[i] > EMA423 && Open[i] > EMA423 && Low[i] < EMA423){
         upmv4 = true;
      }
      else{
         upmv4 = false;
      }

      if(Close[i] < EMA423 && Open[i] < EMA423 && High[i] > EMA423){  // Corrected condition
         dnmv4 = true;
      }
      else{
         dnmv4 = false;
      }
   }
}
else
{
upmv4=true;
dnmv4=true;
}

            if(COMBINER)
              {
               up1 = iCustom(NULL, 0, IndicatorName, IndiBufferCall, i+SignalType);
               dn1 = iCustom(NULL, 0, IndicatorName, IndiBufferPut, i+SignalType);
               up1 = sinal_buffer(up1);
               dn1 = sinal_buffer(dn1);
              }
            else
              {
               up1 = true;
               dn1 = true;
              }

            if(COMBINER2)
              {
               up2 = iCustom(NULL, 0, IndicatorName2, IndiBufferCall2, i+SignalType2);
               dn2 = iCustom(NULL, 0, IndicatorName2, IndiBufferPut2, i+SignalType2);
               up2 = sinal_buffer(up2);
               dn2 = sinal_buffer(dn2);
              }
            else
              {
               up2 = true;
               dn2 = true;
              }

            if(COMBINER3)
              {
               up3 = iCustom(NULL, 0, IndicatorName3, IndiBufferCall3, i+SignalType3);
               dn3 = iCustom(NULL, 0, IndicatorName3, IndiBufferPut3, i+SignalType3);
               up3 = sinal_buffer(up3);
               dn3 = sinal_buffer(dn3);
              }
            else
              {
               up3 = true;
               dn3 = true;
              }

            if(COMBINER4)
              {
               up4 = iCustom(NULL, 0, IndicatorName4, IndiBufferCall4, i+SignalType4);
               dn4 = iCustom(NULL, 0, IndicatorName4, IndiBufferPut4, i+SignalType4);
               up4 = sinal_buffer(up4);
               dn4 = sinal_buffer(dn4);
              }
            else
              {
               up4 = true;
               dn4 = true;
              }

            if(COMBINER5)
              {
               up5 = iCustom(NULL, 0, IndicatorName5, IndiBufferCall5, i+SignalType5);
               dn5 = iCustom(NULL, 0, IndicatorName5, IndiBufferPut5, i+SignalType5);
               up5 = sinal_buffer(up5);
               dn5 = sinal_buffer(dn5);
              }
            else
              {
               up5 = true;
               dn5 = true;
              }

            if(Bloquea)
              {
               candlesup=0;
               candlesdn=0;
               int j;
               for(j = i+quantidade+1 ; j>=i; j--)
                 {
                  if(close[j+1]>=open[j+1]) // && close[j+2] > open[j+2])
                     candlesup++;
                  else
                     candlesup=0;
                  if(close[j+1]<=open[j+1]) // && close[j+2] < open[j+2])
                     candlesdn++;
                  else
                     candlesdn = 0;
                 }
              }

            if(enviar_telegram){

            if( //CALL  ----  ACIMA

               up[i] == EMPTY_VALUE
               && up1  // Combiner
               && up2  // Combiner2
               && up3  // Combiner3
               && up4  // Combiner2
               && up5  // Combiner5
               && up_MFI //MFI
               && up_RVI //RVI
               && up_WPR //WPR
               && up_HUNTER //HUNTER

               && up_hulk //HULK

               && up_ninja //REAPER
               && up_sniper //CRUSHER

               && up_sg  //Reversal
               && up_MACD
               && up_KEN //KEN
               && upmv1
               && upmv2
               && upmv3
               && upmv4
               && up_Stochastic //Stochastic Strategy

               && (!shadow || (shadow && PadraoVelas < minimaEma && close[i]<open[i]))
               &&(!candlestrtegy || (Open [i+1] > Close [i+1])) &&(!candlestrtegy || (Open [i] < Close [i]))
               &&(!candlestrtegy || (Close[i+1] < Open [i])) &&(!candlestrtegy || (Open [i+1] > Close [i]))
               &&(!Bandas || Close[i+0]<iBands(NULL,PERIOD_CURRENT,BB_Period*(TimeFrame2/_Period),BB_Dev,BB_Shift,0,MODE_LOWER,i+0))
               &&(!Bandas || Open[i+0]>iBands(NULL,PERIOD_CURRENT,BB_Period*(TimeFrame2/_Period),BB_Dev,BB_Shift,0,MODE_LOWER,i+0))
               &&(!Bandas || Open[i+1]>iBands(NULL,PERIOD_CURRENT,BB_Period*(TimeFrame2/_Period),BB_Dev,BB_Shift,0,MODE_LOWER,i+1))
               &&(!Bandas || Close[i+1]>iBands(NULL,PERIOD_CURRENT,BB_Period*(TimeFrame2/_Period),BB_Dev,BB_Shift,0,MODE_LOWER,i+1))
               &&(!AtivarCruzamento || fasterEMAnow > slowerEMAnow) &&(!AtivarCruzamento || fasterEMAprevious < slowerEMAprevious) &&(!AtivarCruzamento || fasterEMAafter > slowerEMAafter)

               && up_master //MASTER ESTRATEGIA

               && fora_banda_up //DONCHIAN
               && up_cci //CCI
               && up_KC //kETLER
               && up_adx //ADX
      

Показано первые 50% кода (символов: 141325)