//+------------------------------------------------------------------+
//|                                        Quantum London Trading EA |
//|                                 Copyright 2012-2016, CompanyName |
//|              http://www.forexfactory.com/showthread.php?t=552185 |
//|              http://forum.tradelikeapro.ru/index.php?topic=10633 |
//+------------------------------------------------------------------+ 
#import "user32.dll"
int MessageBoxA(int Ignore,string Caption,string Title,int Icon);
#import
#property strict
#property link "http://www.forexfactory.com/showthread.php?t=551382"
#property link "http://forum.tradelikeapro.ru/index.php?topic=10633"
#include <stdlib.mqh> 
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum Slip_Spred
    {
    does_not_take_into_account,
    Only_when_opened,
    Only_when_closing,
    always_take_into_account_the
    };
enum enum_curtime
    {
    broker,
    GMT
    };
enum enum_oc
    {
    on_the_current_candle,
    on_the_next_candle
    };
enum enum_cycles
    {
    when_opened,
    when_closing
    }; 
input    int                  mn                      =  2016;       //Magic Number
extern   string               comm                    =  "QLT_M41";  //Order Comment
input    bool                 manual                  =  false;      //Manually Close Trades
input    int                  wait                    =  0;          //Wait X boxes before opening trades
input    bool                 onlylowerhigher         =  false;      //Only open higher (sells) or lower (buys) than previous order
input    int                  xdist                   =  0;          //Minimum distance between entries
input    double               multi_xdist             = 1;           // Multiplier distance between orders
input    double               exponent_factor_xdist   = 1;           // Multiplier exponent
extern   bool                 stop                    =  false;      //Stop after each cycle
input    int                  xcandles                =  0;          //Only trade every X candles
input    bool                 reverse                 =  false;      //Reverse Trading (Buy on Red, Sell on Blue)
input    uint                 MaxWaiting = 30; // Maximum waiting time until the trade flow (s)
input    Slip_Spred           Slip_on = 1; // Selection of accounting slip
extern   int                  Slip = 5; // Maximum Slippage
         int Slip_op, Slip_cl;
input    Slip_Spred           Spred_on = 1; // Selection of accounting spreads
input    int                  Spred = 5; // Maximum Spread
input    bool                 ber = false; // Use Break Even Recovery
input    double               percbedd = 0; //% Equity Draw Down to Activate Break Even Recovery
         bool beractive = false;
input    string ll80 = "######################## UNIT The minimum distance in front ################ #### "; // BLOCK minimum distance in front of
input    bool                 GX_on = true; // Enable check
input    string               _GX_time_ = "price fixing time";
input    int                  GX_hour = 10; // clock
input    int                  GX_minut = 00; // minutes
         datetime             GX_time                 =  0;
         double               GX_price                =  0;
         double               GX_price_buy            =  0;
         double               GX_price_sell           =  0;
enum enum_GX_price
   {
   Points,
   ATR,
   Price
   };  
input    enum_GX_price        GX_price_var   = 0; // Distance calculation option (Points,% of ATR, Price)
input    int                  GX_points      = 700; // Distance from the fixed price (Points)
input    int                  GX_points_buy  = 700; // Distance from the fixed price (Points) for BUY orders
input    int                  GX_points_sell = 700; // Distance from the fixed price (Points) for SELL orders
input    double               GX_ATR_perc    = 0; // Distance from the fixed price (% of ATR)
input    int                  GX_ATR_Period  = 14; // Indicator period ATR
input    ENUM_TIMEFRAMES      GX_ATR_TF      = PERIOD_M5; // Timeframe for the ATR indicator
         double GX_ATR = 0;
         datetime bars_GX_ATR;
input    double               GX_Price_buy         = 0; // Price limits for BUY orders (Price Mode)
input    double               GX_Price_sell        = 0; // Border price for SELL orders (Price Mode)
input    ENUM_LINE_STYLE      GX_Line_STYLE        = 0; // Line Style
input    color                GX_Line_color        = clrWhite; // The color of the line fixed price
input    color                GX_Line_color_buy    = clrWhite; // Border line color to BUY
input    color                GX_Line_color_sell   = clrWhite; // Border line color for SELL

input    string mm04="######################## UNIT SL/TP  ####################"; // ÁËÎÊ SL/TP
input    int                  pointstp             =  0;                      //Points Take Profit (Eg. 100)
input    double               dollartp             =  0;                      //$ Take Profit (Eg. 100)
input    double               percequitytp         =  0;                      //% Equity Take Profit (Eg. 10)
input    int                  pointssl             =  0;                      //Points Stop Loss (Eg. -100)
input    double               dollarsl             =  0;                      //$ Stop Loss (Eg. -50)
input    double               percequitysl         =  0;                      //% Equity Stop Loss (Eg. -10)
input    enum_GX_price        indiv_var         = 0;           // Calculate Option Individual SL / TP (Points,% of ATR)
input    double               indivtp           = 0;           // Individual Trade TP
input    double               indivsl           = 0;           // Individual Trade SL
input    int                  indiv_Period_tp   = 13;          // Period of the ATR indicator for the Individual Trade TP
input    int                  indiv_Period_sl   = 13;          // Period of the ATR indicator for the Individual Trade SL
input    ENUM_TIMEFRAMES      indiv_ATR_TF      = PERIOD_D1;   // ATR indicator Timeframe for Individual Trade
input    bool                 stop_sl           = false;       // switch-mode "Stop after each cycle" when the SL
input    string mnn10="######################## ÁËÎÊ Close only in profit  ####################"; // ÁËÎÊ Close only in profit
input    int                  CloseProfit_min   = 0; // The number of orders to enable mode (0-off)
input    int                  CloseProfit_max   = 0; // The number of orders for the shutdown mode (0-not used)
input    double               CloseProfit       = 0; // Close only in profit ($)
input    int                  CloseProfit_Points = 0; // Close only in profit (Points)
input    double               CP_ATR_perc       = 0; // Close only in profit (% of ATR)
input    int                  CP_ATR_Period     = 0; // Indicator period ATR
input    ENUM_TIMEFRAMES      CP_ATR_TF         = PERIOD_H1; // Timeframe for the ATR indicator
input    double               CP_ATR_ED         = 0; // Exponent divider / splitter exponent
input    bool                 CP_TS             = false; // Disable validation after issuing the TS
         double            CP_ATR                  =  0;
         datetime          bars_CP_ATR;
         bool              CP_buy                  =  true;
         bool              CP_sell                 =  true;
input string mn01 = "################## LOT BLOCK SELECTION ## "; // BOX LOT OF CHOICE
enum enum_optionLot
   {
   Fixed,
   PercDepo,
   Classical,
   Grid
   }; 
input    enum_optionLot    optionLot = 0;       // Select the option of the lot
input    double            FixLot = 0.1;        // Mode "Fixed" volume fixed initial bid
extern   double            PercentOfDepo = 1;   // Mode "PercentOfDepo" lot size in% of available funds
         double            FirstLot = 0;        // Size of the initial bid in a mode of "PercentOfDepo"
input    double            multip1 = 1.01;         // 1st bid multiplier
input    double            multip2 = 1.11;         // Multiplier exponent
extern   double            AccFreeMargin = 0.0;    // Test: a new grid with a fixed margin
         double            Test_Free_Margin = 0.0; // Test: the value of the margin before the opening of the grid
         double            MAX_EQUITY_DD;          // Test: the maximum drawdown
input    string mn02="=======================     Section Classical   ====================="; // âûáîð ëîòà ïî ïðàâèëàì ÒÑ
input    double            T1                      =  0.01;                   //Trades 1-12
input    double            T2                      =  0.02;                   //Trades 13-21
input    double            T3                      =  0.05;                   //Trades 22-29
input    double            T4                      =  0.13;                   //Trades 30-36
input    double            T5                      =  0.34;                   //Trades 37-39
input    double            T6                      =  0.89;                   //Trade 40 & >
input    string mn03="=======================     Section Grid        ====================="; // âûáîð ëîòà ïî ïàðàìåòðàì êîðçèí îðäåðîâ
         double g1s, g2s, g3s,g4s;
input    bool              drawgrid                =  false;                  //Draw Grid Lines
input    int               grid1size               =  0;                      //Grid 1 Size (Eg. 100)
input    int               grid1inc                =  0;                      //Grid 1 Increment (Space between entries)
input    int               grid1maxtrades          =  0;                      //Max Trades For Grid 1
input    double            grid1lots               =  0;                      //Grid 1 Lots
input    int               grid2size               =  0;                      //Grid 2 Size (Eg. 100)
input    int               grid2inc                =  0;                      //Grid 2 Increment (Space between entries)
input    int               grid2maxtrades          =  0;                      //Max Trades For Grid 2
input    double            grid2lots               =  0;                      //Grid 2 Lots
input    int               grid3size               =  0;                      //Grid 3 Size (Eg. 100)
input    int               grid3inc                =  0;                      //Grid 3 Increment (Space between entries)
input    int               grid3maxtrades          =  0;                      //Max Trades For Grid 3
input    double            grid3lots               =  0;                      //Grid 3 Lots
input    int               grid4size               =  0;                      //Grid 4 Size (Eg. 100)
input    int               grid4inc                =  0;                      //Grid 4 Increment (Space between entries)
input    int               grid4maxtrades          =  0;                      //Max Trades For Grid 4
input    double            grid4lots               =  0;                      //Grid 4 Lots
input    string   mmn01 = "######################## ############# UNIT CONTROL VEHICLES"; // CONTROL UNIT FUNDS
extern   double            MaxPercDepo             = 0; // Maximum drawdown in% of the deposit
extern   double            MaxPercFree             = 100; // Available funds as a% of the free
input    string mm01 = "######################## unit settings pending order ##"; // BLOCK SETTINGS pending order
         double Virt_Order_buy         = 0; // Price BUY orders
         double Virt_Order_sell        = 0; // Price SELL orders
         double Virt_Order_dist;
input    bool              Virt_Order_on  = false; // Switch mode
input    bool              Virt_TS_on     = false; // Virtual TS
input    double            Virt_Order_dist_perc    = 0; // Distance in% from the Asia-Pacific region
input    ENUM_TIMEFRAMES   Virt_Order_TF           = PERIOD_D1; // Timeframe ATR indicator for the distance
input    int               Virt_Order_Period       = 14; // ATR period for distance
input    color              Virt_Order_color       = clrYellow; // Color Line orders
input    ENUM_LINE_STYLE   Virt_Order_LINE_STYLE   = 0; // Style line orders
         datetime          bars_Virt_Order         = iTime(NULL,Virt_Order_TF,2);

input    string lmn0 = "######################## unit settings Quantum ###############"; // Quantum unit settings
input    ENUM_TIMEFRAMES   tf          = PERIOD_M1; // Time Frame / Quantum timeframe indicator
input    int               qde_general = 325; // Quantum eintDepth3 for Entry
input    enum_oc           qde_oc      = 1; // Indicator analysis
input    int               qde_bars    = 0; // Number of bars of signal preservation
         int               qde_bars_count_buy = 0; // Count the number of signal bars conservation
         int               qde_bars_count_sell = 0; // Count the number of signal bars conservation
input    enum_GX_price     qde_price_var  = 0; // Calculate the distance to the boundary Option conservation areas (Points,% of ATR)
input    int               qde_points     = 0; // Save the boundary signal (Points)
input    double            qde_ATR_perc   = 0; // Save the boundary signal (% of ATR)
input    int               qde_ATR_Period = 14; // Indicator period ATR
input    ENUM_TIMEFRAMES   qde_ATR_TF     = PERIOD_M5; // Timeframe for the ATR indicator
         double qde_Line = 0; // The value of border prices
         datetime bars_qde_ATR;
input    color             qde_Line_color_buy = clrWhite; // Border color for BUY
input    color             qde_Line_color_sell = clrWhite; // Border color for SELL

input    int               qdc_general             =  325;                    //Quantum eintDepth3 for Close
         int               qde                     =  0;
         int               qdc                     =  0;
         double            Quantum_op_buy          =  0;
         double            Quantum_op_sell         =  0;
         double            Quantum_cl_buy; 
         double            Quantum_cl_sell; 

input string ll50 = "######################## unit settings Stochastic ############"; // BLOCK SETTINGS Stochastic
         double Stochastic_op, Stochastic_cl;
input    ENUM_TIMEFRAMES   Stochastic_tf           = PERIOD_M1;                              // Source data timeframe 
         datetime bars_Stochastic_tf;
input string ll51 = "======================== subblocks Stochastic to enter ==========="; // Stochastic to enter the sub-block
input    bool              Stochastic_op_on        = false; // Switch indicator
input    int               Stochastic_K_op         =  5;                                              // K Period
input    int               Stochastic_D_op         =  3;                                              // D Period
input    int               Stochastic_S_op         =  3;                                              // Slowing
input    int               Stochastic_OS_op        =  20;                                             // OS levels
input    int               Stochastic_OB_op        =  80;                                             // OB levels
input string LL52 = "======================== Stochastic sub-block to exit ==========="; // Stochastic sub-block to exit
input    bool              Stochastic_cl_on   = false; // Switch indicator
input    int               Stochastic_K_cl   = 5;// K Period
input    int               Stochastic_D_cl   = 3;// D Period
input    int               Stochastic_S_cl   = 3;// Slowing
input    int               Stochastic_OS_cl  = 20;// OS levels
input    int               Stochastic_OB_cl  = 80;// OB levels
input    string ll73="############################ unit settings PFE ######################";      // unit settings PFE
input    ENUM_TIMEFRAMES      Pfe_tf                      =  PERIOD_M5;                         // Source data timeframe 
datetime             bars_Pfe_tf;
double               Pfe_op,Pfe_cl;
input    string ll74="============================ PFE to enter the sub-block  ========";    // PFE to enter the sub-block
input    bool                 Pfe_op_on                         =  false;                        // Switch indicator
input    int                  Pfe_Period_op                     =  16;                           // Pfe period 
input    bool                 Pfe_UseAvarage_op                 =  true;                         // averaging mode 
input    int                  Pfe_MaPeriod_op                   =  4;                            // MA period 
input    ENUM_MA_METHOD       Pfe_MODE_MA_op                    = MODE_SMA;                      // MA method
input    double               Pfe_Level_op                      =  0.2;                          // The threshold entry level 
input    string ll75="============================ PFE sub-block to exit  =======";           // PFE sub-block to exit
input    bool                 Pfe_cl_on                      =  false;                        // Switch indicator
input    int                  Pfe_Period_cl                     =  16;                            // Pfe period 
input    bool                 Pfe_UseAvarage_cl                 =  true;                         // averaging mode
input    int                  Pfe_MaPeriod_cl                   =  4;                            // MA period
input    ENUM_MA_METHOD       Pfe_MODE_MA_cl                    = MODE_SMA;                      // MA method
input    double               Pfe_Level_cl                      =  0;                            // The threshold exit level  


input string qq2 = "######################### unit settings _MACD_Xtr ################# "; // BLOCK SETTINGS _MACD_Xtr
         double MACD_Xtr_3, MACD_Xtr_4, MACD_Xtr_3_cl, MACD_Xtr_4_cl;
input ENUM_TIMEFRAMES MACD_Xtr_tf = PERIOD_M1; // Source data timeframe / Timeframe source data
         datetime bars_MACD_Xtr_tf, bars_MACD_Xtr_tf_cl;
input string qq3 = "======================== subblocks _MACD_Xtr to enter ==========="; // Sub-block to enter _MACD_Xtr
input    bool MACD_Xtr_on  = false; // Switch indicator
input    int FastMA        = 12; // Period of the fast EMA
input    int SlowMA        = 26; // Period of slow EMA
input    int Source        = 1; // Source of volatility: 0 - volume 1 - the ATR, 2 - stdev
input    int SourcePeriod  = 5; // Period of volatility source
      // signal
input    double   BackPeriod = 444; // Smoothing period attenuation; mb <1
   // Levels of PC / PP
input    double   xVolatility = 0.5;
input    double   Sens = 0; // Threshold in paragraphs. or in ticks (for volume)
input    string qq4 = "======================== subblocks _MACD_Xtr =========== To exit"; // To exit the sub-block _MACD_Xtr
input    bool  MACD_Xtr_cl_on = false; // Switch indicator
input    int   FastMA_cl      = 12; // Period of the fast EMA
input    int   SlowMA_cl      = 26; // Period of slow EMA
input    int   Source_cl      = 1; // Source of volatility: 0 - volume 1 - the ATR, 2 - st.deviatsiya
input    int   SourcePeriod_cl = 5; // Period of volatility source
      // ñèãíàëüíàÿ
input    double BackPeriod_cl = 444; // Smoothing period attenuation; mb <1
   // Levels of PC / PP
input    double xVolatility_cl = 0.5;
input    double Sens_cl = 0; // Threshold in paragraphs. or in ticks (for volume)
input    string qq5 = "######################## unit settings Envelopes ##############"; // BLOCK SETTINGS Envelopes
         double Envelopes_op_UP, Envelopes_op_LO, Envelopes_cl_UP, Envelopes_cl_LO;
input ENUM_TIMEFRAMES Envelopes_tf = PERIOD_M1; // Source data timeframe / Timeframe source data
         datetime bars_Envelopes_tf, bars_Envelopes_tf_cl;
input string qq6 = "======================== Envelopes sub-block to enter ==========="; // Envelopes sub-blocks for inputs
input    bool  Envelopes_on = false; // Switch indicator
input    int   MA_Period = 14; //Period
input    int   MA_Shift = 0; //Shift
input    ENUM_MA_METHOD       MA_Method                  = MODE_SMA;
input    ENUM_APPLIED_PRICE   Applied_Price              = PRICE_CLOSE;
input string qq61 = "- 1 = 23.6; -2 = 38.2; -3 = 50.0; -4 = 61.8; -5 = 78.6; -6 = 82.87 (Gann); - 7 = 88.2"; // Fixed value of the parameter "Deviation in%"
extern double Deviation = 0.1; // Deviation in%
input string qq7 = "======================== Envelopes sub-block to exit =========="; // Envelopes sub-block to exit
input bool Envelopes_cl_on = false; // Switch indicator
input int MA_Period_cl = 14; //Period
input int MA_Shift_cl = 0; //Shift
input ENUM_MA_METHOD MA_Method_cl = MODE_SMA;
input ENUM_APPLIED_PRICE Applied_Price_cl = PRICE_CLOSE;
input string qq71 = "- 1 = 23.6; -2 = 38.2; -3 = 50.0; -4 = 61.8; -5 = 78.6; -6 = 82.87 (Gann); - 7 = 88.2"; // The fixed value of the parameter "Deviation in%"
extern double Deviation_cl = 0.1; // Deviation in%
input bool env_open_cl = false; // Search the signal on the input side relative to MA
input string ll9 = "###################### unit settings ChannelsFIBO_MTF_AD_EA ##"; // BLOCK SETTINGS ChannelsFIBO_MTF_AD_EA
          double ChannelsFIBO_MTF_op_0, ChannelsFIBO_MTF_op_1, ChannelsFIBO_MTF_cl_0, ChannelsFIBO_MTF_cl_1;
          datetime bars_ChannelsFIBO_MTF_tf, bars_ChannelsFIBO_MTF_cl_tf;
input string ll10 = "====================== ChannelsFIBO_MTF_AD_EA sub-blocks for input ="; // Sub-block to enter ChannelsFIBO_MTF_AD_EA
input bool ChannelsFIBO_MTF_AD_EA_on = false; // Switch indicator
input    ENUM_TIMEFRAMES      i_tf                          = PERIOD_H1;                              // Source data timeframe 
input    uint                 i_extremumDepth               = 78;                                     // Depth extremum search 
input    uint                 i_maPeriod                    = 100;                                    // MA period 
input    ENUM_MA_METHOD       i_maMethod                    = MODE_SMA;                               // MA method 
input    ENUM_APPLIED_PRICE   i_maPrice                     = PRICE_CLOSE;                            // MA price 
input string ll12 = "- 1 = 23.6; -2 = 38.2; -3 = 50.0; -4 = 61.8; -5 = 78.6; -6 = 82.87 (Gann); - 7 = 88.2; -8 = 100.0"; // The fixed value of the parameter "Fibo level 1"
extern double i_fiboLevel1 = 23.6; // Fibo level 1 / level 1 Fib
input int i_indBarsCount = 2; // Number of bars to display / Max display bars
input string ll11 = "====================== ChannelsFIBO_MTF_AD_EA sub-block to exit ="; // To exit the sub-block ChannelsFIBO_MTF_AD_EA
input    bool                 ChannelsFIBO_MTF_AD_EA_cl_on  = false;                                  // Switch indicator
input    ENUM_TIMEFRAMES      i_tf_cl                       = PERIOD_H1;                              // Source data timeframe
input    uint                 i_extremumDepth_cl            = 78;                                     // Depth extremum search 
input    uint                 i_maPeriod_cl                 = 100;                                    // MA period
input    ENUM_MA_METHOD       i_maMethod_cl                 = MODE_SMA;                               // MA method
input    ENUM_APPLIED_PRICE   i_maPrice_cl                  = PRICE_CLOSE;                            // MA price 
input string ll13 = "- 1 = 23.6; -2 = 38.2; -3 = 50.0; -4 = 61.8; -5 = 78.6; -6 = 82.87 (Gann); - 7 = 88.2; -8 = 100.0"; // The fixed value of the parameter "Fibo level 1"
extern double i_fiboLevel1_cl = 23.6; // Fibo level 1
input int i_indBarsCount_cl = 2; // Number of bars to display
input bool i_open_cl = false; // Search the signal on the input side relative to MA
input string ll20 = "####################### unit settings ChannelsFIBO_v2_MTF_AD_EA #"; // BLOCK SETTINGS ChannelsFIBO_v2_MTF_AD_EA
enum ENUM_SHIFT_METHOD
{
   SHIFT_MAXIMUM,                                                                                  // By maximal shift 
   SHIFT_AVERAGE,                                                                                  // By average shift 
   SHIFT_MEDIAN,                                                                                   // By median shift 
   SHIFT_STD                                                                                       // By standart deviation 
};
         double ChannelsFIBO_v2_op_0, ChannelsFIBO_v2_op_1, ChannelsFIBO_v2_cl_0, ChannelsFIBO_v2_cl_1;
         datetime bars_ChannelsFIBO_v2_tf, bars_ChannelsFIBO_v2_cl_tf;
input string ll21 = "============================================= ======================== "; // Sub-block to enter ChannelsFIBO_v2_MTF_AD_EA
input bool ChannelsFIBO_v2_MTF_AD_EA_on = false; // Switch indicator
input    ENUM_TIMEFRAMES      i_tf_v2                          = PERIOD_H1;                              // Source data timeframe 
input    uint                 i_extremumDepth_v2               = 78;                                     // Depth extremum search 
input    uint                 i_maPeriod_v2                    = 100;                                    // MA period 
input    ENUM_MA_METHOD       i_maMethod_v2                    = MODE_SMA;                               // MA method 
input    ENUM_APPLIED_PRICE   i_maPrice_v2                     = PRICE_CLOSE;                            // MA price 
input    string ll23 ="fixed -1=23.6;-2=38.2;-3=50.0;-4=61.8;-5=78.6;-6=82.87(Gann);-7=88.2;-8=100.0";   
extern   double               i_fiboLevel1_v2                  = 23.6;                                   // Fibo level 1 
input    ENUM_SHIFT_METHOD    i_shiftMethod_v2                 = SHIFT_STD;                              // Channel calculate method 
input    int                  i_indBarsCount_v2                = 2;                                      // Number of bars to display 
input string ll22 = "============================================= ======================== "; // To exit the sub-block ChannelsFIBO_v2_MTF_AD_EA
input bool ChannelsFIBO_v2_MTF_AD_EA_cl_on = false; // Switch indicator
input    ENUM_TIMEFRAMES      i_tf_v2_cl                       = PERIOD_H1;                              // Source data timeframe 
input    uint                 i_extremumDepth_v2_cl            = 78;                                     // Depth extremum search 
input    uint                 i_maPeriod_v2_cl                 = 100;                                    // MA period 
input    ENUM_MA_METHOD       i_maMethod_v2_cl                 = MODE_SMA;                               // MA method
input    ENUM_APPLIED_PRICE   i_maPrice_v2_cl                  = PRICE_CLOSE;                            // MA price
input    string ll24 ="-1=23.6;-2=38.2;-3=50.0;-4=61.8;-5=78.6;-6=82.87(Gann);-7=88.2;-8=100.0";         
extern   double               i_fiboLevel1_v2_cl               = 23.6;                                   // Fibo level 1
input    ENUM_SHIFT_METHOD    i_shiftMethod_v2_cl              = SHIFT_STD;                              // Channel calculate method
input    int                  i_indBarsCount_v2_cl             = 2;                                      // Number of bars to display
input bool i_open_v2_cl = false; // Search the signal on the input side relative to MA

input string ll40 = "############################################# ######################## "; // BLOCK SETTINGS ATR Channels
          double ATR_op_0, ATR_op_1, ATR_cl_0, ATR_cl_1;
input ENUM_TIMEFRAMES ATR_tf = PERIOD_M1; // Source data timeframe
          datetime bars_ATR_tf, bars_ATR_tf_cl;
input string ll41 = "============================================= ======================== "; // ATR Channels sub-blocks for inputs
input bool ATR_Channels_op_on = false; // Switch indicator
input int ATR_PeriodsATR_on = 24; // Averaging period for calculating the ATR indicator
input int ATR_MA_Periods_on = 100; // MA period
input ENUM_MA_METHOD ATR_MA_type_on = MODE_LWMA; // MA method
extern double ATR_Mult_Factor1_on = 3.62; // Channel level relative to MA
input ENUM_APPLIED_PRICE ATR_applied_price_on = PRICE_TYPICAL; // MA price
input int ATR_fontsize_on = 8; // font size
input string ll42 = "============================================= ======================== "; // Sub-blocks for outputs ATR Channels
input    bool                 ATR_Channels_cl_on               = false;                                  // Switch indicator
input int ATR_PeriodsATR_cl = 24; // Averaging period for calculating the ATR indicator
input int ATR_MA_Periods_cl = 100; // MA period
input ENUM_MA_METHOD ATR_MA_type_cl = MODE_LWMA; // MA method
extern double ATR_Mult_Factor1_cl = 3.62; // Channel level relative to MA
input ENUM_APPLIED_PRICE ATR_applied_price_cl = PRICE_TYPICAL; // MA price
input int ATR_fontsize_cl = 8; // font size
input bool ATR_Channels_op_cl = false; // Search the signal on the input side relative to MA

input string ll60 = "############################################# ######################## "; // BLOCK SETTINGS moving_averages_Kiosotto
         double   MA_Kiosotto_op_buy,MA_Kiosotto_op_sell,MA_Kiosotto_cl_buy,MA_Kiosotto_cl_sell,MA_Kiosotto_MA_op=0,MA_Kiosotto_MA_cl=0;
enum ENUM_YESNO
{
   NO,                                                                                             // No 
   YES                                                                                             // Yes
};
input    string ll61="====================================================================="; // Sub-block moving averages Kiosotto for entry
input    bool                 MA_Kiosotto_op_on                =  false;                                 // Switch indicator
input    ENUM_TIMEFRAMES      MA_Kiosotto_tf_op                =  PERIOD_M1;                             // Source data timeframe 
extern   int                  MA_Kiosotto_i_dev_period_op      =  5;                                     // RSI period 
extern   int                  MA_Kiosotto_MA_Period_op         =  13;                                    // MA period 
input    ENUM_MA_METHOD       MA_Kiosotto_i_maMethod_op        =  MODE_EMA;                              // MA calculation method 
extern   double               MA_Kiosotto_g_shift_op           =  1;                                     // MA ratio  
input    ENUM_YESNO           MA_Kiosotto_i_useAlert_op        =  NO;                                    // Use alert? 
extern   int                  MA_Kiosotto_i_indBarsCount_op    =  10000;                                 // The number of bars to display
input string ll62 = "============================================= ======================== "; // Sub-block moving averages Kiosotto to exit
input    bool                 MA_Kiosotto_cl_on                = false;                                  // Switch indicator
input    ENUM_TIMEFRAMES      MA_Kiosotto_tf_cl                = PERIOD_M1;                              // Source data timeframe 
extern   int                  MA_Kiosotto_i_dev_period_cl      =  5;                                     // RSI period 
extern   int                  MA_Kiosotto_MA_Period_cl         =  13;                                    // MA period 
input    ENUM_MA_METHOD       MA_Kiosotto_i_maMethod_cl        =  MODE_EMA;                              // MA calculation method 
extern   double               MA_Kiosotto_g_shift_cl           =  1;                                     // MA ratio  
input    ENUM_YESNO           MA_Kiosotto_i_useAlert_cl        =  NO;                                    // Use alert? 
extern   int                  MA_Kiosotto_i_indBarsCount_cl    =  10000;                                 // The number of bars to display
         datetime bars_MA_Kiosotto_tf_op = iTime(NULL,MA_Kiosotto_tf_op,2);
         datetime bars_MA_Kiosotto_tf_cl = iTime(NULL,MA_Kiosotto_tf_cl,2);

input    string ll70="#####################################################################";      //  The Moving Average parameters
input    string ll71="====================================================================="; // The Moving Average parameters for entry
         double               iMA_op;
input    bool                 iMA_op_on                        =  false;                                 // Switch indicator
input    ENUM_TIMEFRAMES      iMA_timeframe_op                 =  PERIOD_M1;                             // Source data timeframe  
input    int                  iMA_ma_period_op                 =  13;                                    // MA period 
input    int                  iMA_ma_shift_op                  =  0;                                     // ma_shift 
input    ENUM_MA_METHOD       iMA_ma_method_op                 =  MODE_EMA;                              // MA calculation method  
input    ENUM_APPLIED_PRICE   iMA_applied_price_op             =  PRICE_CLOSE;                           // MA price 
         datetime             bars_iMA_timeframe_op            =  iTime(NULL,iMA_timeframe_op,2);
input    string ll72="====================================================================="; // The Moving Average parameters to exit
         double               iMA_cl;
input    bool                 iMA_cl_on                        =  false;                                 // Switch indicator
input    ENUM_TIMEFRAMES      iMA_timeframe_cl                 =  PERIOD_M1;                             // Source data timeframe  
input    int                  iMA_ma_period_cl                 =  13;                                    // MA period 
input    int                  iMA_ma_shift_cl                  =  0;                                     // ma_shift 
input    ENUM_MA_METHOD       iMA_ma_method_cl                 =  MODE_EMA;                              // MA calculation method 
input    ENUM_APPLIED_PRICE   iMA_applied_price_cl             =  PRICE_CLOSE;                           // MA price 
         datetime             bars_iMA_timeframe_cl            =  iTime(NULL,iMA_timeframe_cl,2);
input    string ll82="####### ÁËÎÊ ÍÀÑÒÐÎÅÊ MA-4H #########################################";      // The MA-4H parameters
input    bool                 MA_4H_op_on                      =  false;                                 // Switch indicator
input enum_GX_price MA_4H_price_var = 0; // Distance calculation option (Points,% of ATR)
input ENUM_TIMEFRAMES MA_4H_timeframe_op = PERIOD_H1; // Source data timeframe / Timeframe source data
input int MA_4H_ma_period_op = 13; // MA period / period MA
input int MA_4H_ma_shift_op = 0; // Shift the average
input ENUM_MA_METHOD MA_4H_ma_method_op = MODE_SMA; // MA calculation method
input ENUM_APPLIED_PRICE MA_4H_applied_price_op = PRICE_CLOSE; // MA price
input int MA_4H_level_1 = 100; // Distance to near the level (Points)
input int MA_4H_level_2 = 300; // Distance to further levels (Points)
input double MA_4H_ATR_perc_level_1 = 10; // Distance to near the level (% of ATR)
input double MA_4H_ATR_perc_level_2 = 30; // Distance to further levels (% of ATR)
input int MA_4H_ATR_Period = 13; // Indicator period ATR
input ENUM_TIMEFRAMES MA_4H_ATR_TF = PERIOD_D1; // Timeframe for the ATR indicator
         double               MA_4H_level_0, MA_4H_ATR_level_1, MA_4H_ATR_level_2;
         datetime             bars_MA_4H_timeframe_op          =  iTime(NULL,MA_4H_timeframe_op,2);
         datetime             bars_MA_4H_ATR_op                =  iTime(NULL,MA_4H_ATR_TF,2);

input string lll3="=====================================================================";// ================================================


input bool had=false;//Weekly Heiken Ashi Filter


input string aal = "### BLOCK TRADE ADJUSTMENT TIME ################################"; // If Trade 24/5 = false then

       datetime open1, close1, open2, close2, open3, close3;
input bool fulltime = true; // Trade 24/5 (twenty-four hours trade)
input bool           mon            =true;//Trade on Monday
input bool           tue            =true;//Trade on Tuesday
input bool           wed            =true;//Trade on Wednesday
input bool           thurs          =true;//Trade on Thursday
input bool           fri            =true;//Trade on Friday
input int            numcycles      =0;//Number of Daily Cycles to run
input enum_curtime CT = 1; // timing for the broker or GMT
input enum_cycles cyc_var = 1; // version of the work cycle counter
input bool contgrid = true; // Continued construction of the grid at the end of trading hours
input string _open1_ = "Opening Hours 1st session";
input int open1hour = 07; // clock
input int open1minut = 00; // minutes
input string _close1_ = "Closing Time 1st session";
input int close1hour = 13; // Watches
input int close1minut = 00; // minutes
input int            qde1           =0;//Quantum eintDepth3 for Entry per Trading Slot 1
input int            qdc1           =0;//Quantum eintDepth3 for Close per Trading Slot 1
input int            cyc1           =0;//Max Cycles per Trading Slot 1
input int            trad1          =0;//Max Trades per Cycle Slot 1
input string _open2_ = "Opening Hours 2nd session";
input int open2hour = 07; // clock
input int open2minut = 00; // minutes
input string _close2_ = "Closing Time 2nd session";
input int close2hour = 13; // Watches
input int close2minut = 00; // minutes
input int qde2 = 0; // Quantum eintDepth3 for Entry per Trading Slot 2
input int qdc2 = 0; // Quantum eintDepth3 for Close per Trading Slot 2
input int cyc2 = 0; // Max Cycles per Trading Slot 2
input int trad2 = 0; // Max Trades per Cycle Slot 2
input string _open3_ = "Opening Hours third session";
input int open3hour = 07; // clock
input int open3minut = 00; // minutes
input string _close3_ = "closing the third session of the Time";
input int close3hour = 13; // Watches
input int close3minut = 00; // minutes
input int qde3 = 0; // Quantum eintDepth3 for Entry per Trading Slot 3
input int qdc3 = 0; // Quantum eintDepth3 for Close per Trading Slot 3
input int cyc3 = 0; // Max Cycles per Trading Slot 3
input int trad3 = 0; // Max Trades per Cycle Slot 3
input bool closeend = false; // Close all trades at End Time
input string lll4 = "============== ban period closing ============================ == "; // Ban period closing
          datetime NC_1, NC_2;
input bool NC_on = false; // Switch mode
input string _No_close_1 = "start time"; // Time period
input int NC_1_hour = 22; // clock
input int NC_1_minut = 00; // minutes
input string _No_close_2 = "end time period"; // End time period
input int NC_2_hour = 06; // Watches
input int NC_2_minut = 00; // minutes

input string ll31 = "############################################# ######################## "; // BLOCK SETTINGS "Trailing Stop"
enum ENUM_GridTS
{
   TS_OFF,                                                     // Not used
   TS_IND,                                                     // Based indicators
   TS_EXC                                                      // excluding indicators
};
extern ENUM_GridTS GridTSon = TS_OFF; // Option Trailing Stop
input int ATR_Period = 14; // Period indikaiora ATR
input ENUM_TIMEFRAMES TF_ATR = PERIOD_D1; // Timeframe for the ATR indicator
input double percTS_ATR = 0; // Condition: the distance from the net price to the current price as a% of ATR
         string TS_Name;


input double percTSstep_ATR = 0; // TS distance from the line to the current price (in% ATR)
input double TS_ATR_ED = 0; // Exponent divider / splitter exponent
input color GridTScolor = clrWhite; // Line color TS
input ENUM_LINE_STYLE TS_LINE_STYLE = 0; // Line style TS
         datetime bars_TS_ATR = iTime (NULL, TF_ATR, 2);
input    string ll32 ="=====================================================================";     //================================================ 
input bool debug=false;//Debug Mode

double lots,prevorderprice,retlots;
datetime curtime,prevtime,prevday;
bool donefortheday,buys,buyclosed,sellclosed;
double initialstartbuy,initialstartsell;
double digits,avgpriceSELL,avgpriceBUY,avgpriceSELLlot,avgpriceBUYlot;
int openorders,openorders_old,thewaitbuy,thewaitsell, cycles,c1,c2,c3;
double GridTS=0; //ïåðåìåííûå äëÿ ðàñ÷åòà òðåéëèíã-ñòîïîâ
int   countbuy       = 0;
int   countsell      = 0;
double profitSELL=0;
double profitBUY=0;
double TS_ATR, TS_ATR1,TSstep_ATR; 
int grid1trades,grid2trades,grid3trades,grid4trades,bopenorders,sopenorders,ticket,ticketn,numtrades;
int lastorderbar=0;
datetime bars = iTime(NULL,tf,2);
double   MP10D = MathPow(10,Digits);
bool barNext;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
{
   if (!IsTesting())
   {
      for(int i=OrdersTotal()-1;i>=0;i--)
      {
         if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))     continue;
         if(OrderSymbol()!=Symbol() && OrderMagicNumber()==mn)
         {
            Alert("Ñðàáîòàë ñòîï, ïàðàìåòð Magic Number = ", mn ,"óæå èñïîëüçóåòñÿ íà èíñòðóìåíòå - ",OrderSymbol());
            ExpertRemove(); int b = 0; int stop_ea = 1/b;
         }
      }
   }      
   if(CT==0)curtime=TimeCurrent();
   else     curtime=TimeGMT();
   DeleteLines();
   prevday=iTime(Symbol(),PERIOD_D1,1);
   comm = comm+"_"+DoubleToStr(Period(), 0)+"_"+DoubleToStr(mn, 0);   

   switch (Slip_on)
   {                                       
      case 0: Slip_op = 1000; Slip_cl = 1000; break;             
      case 1: Slip_op = Slip; Slip_cl = 1000; break;             
      case 2: Slip_op = 1000; Slip_cl = Slip; break;             
      case 3: Slip_op = Slip; Slip_cl = Slip;              
   }
   digits=1;
   if (MaxPercDepo <= 0 || MaxPercDepo > 100) 
      MaxPercDepo = 1;
   else 
      MaxPercDepo = MaxPercDepo /100;
   if (MaxPercFree <= 0 || MaxPercFree > 100) 
      MaxPercFree = 1;
   else 
      MaxPercFree = MaxPercFree /100;
   countbuy    = CountTrades (OP_BUY);
   countsell   = CountTrades (OP_SELL);
   Virt_Order_buy=0;
   Virt_Order_sell=0;
   if (Virt_TS_on)
      GridTSon = 0;
   openorders = countbuy + countsell;
   openorders_old = openorders;
   if(CP_ATR_perc >0 && CP_ATR_Period>0)
   {
      bars_CP_ATR = iTime (NULL, CP_ATR_TF,1);
      CP_ATR = percATR (CP_ATR_perc,CP_ATR_TF,CP_ATR_Period)*MP10D/MathPow(openorders+1, CP_ATR_ED);
      if((Slip_on == 2 || Slip_on == 3) && CP_ATR < Slip_cl)
         CP_ATR = Slip_cl;
   }
   if (GridTSon > 0)
   {
      TS_ATR=percATR (percTS_ATR,TF_ATR,ATR_Period);
      TSstep_ATR=percATR(percTSstep_ATR,TF_ATR, ATR_Period)/MathPow(openorders+1,TS_ATR_ED);   
   }
   if (GX_on)
   {
      if(GX_price_var < 2)
         GX_time = StrToTime(StringConcatenate(IntegerToString(GX_hour,   2,'0'),":",IntegerToString(GX_minut, 2,'0')));
      GX_Price();      
   }
   if (!fulltime)
   {
      open1 =  StrToTime(StringConcatenate(IntegerToString(open1hour,   2,'0'),":",IntegerToString(open1minut, 2,'0')));
      close1=  StrToTime(StringConcatenate(IntegerToString(close1hour,  2,'0'),":",IntegerToString(close1minut,2,'0')));
      open2 =  StrToTime(StringConcatenate(IntegerToString(open2hour,   2,'0'),":",IntegerToString(open2minut, 2,'0')));
      close2=  StrToTime(StringConcatenate(IntegerToString(close2hour,  2,'0'),":",IntegerToString(close2minut,2,'0')));
      open3 =  StrToTime(StringConcatenate(IntegerToString(open3hour,   2,'0'),":",IntegerToString(open3minut, 2,'0')));
      close3=  StrToTime(StringConcatenate(IntegerToString(close3hour,  2,'0'),":",IntegerToString(close3minut,2,'0')));
   }
   if (NC_on)
   {
      NC_1  =  StrToTime(StringConcatenate(IntegerToString(NC_1_hour,   2,'0'),":",IntegerToString(NC_1_minut, 2,'0')));
      NC_2  =  StrToTime(StringConcatenate(IntegerToString(NC_2_hour,   2,'0'),":",IntegerToString(NC_2_minut, 2,'0')));
   }
   if(Virt_Order_on) 
      Virt_Order_dist=percATR(Virt_Order_dist_perc,Virt_Order_TF,Virt_Order_Period);
   Lastorderbar();
   if(wait>0)
   {
      if(countbuy >0)
         thewaitbuy = wait +1;
      if(countsell >0)
         thewaitsell = wait +1;
   }
   if(stop==true)
      CreateButton();
   if(manual==true)
      CreateManualButton();
   if(GridTSon > 0 && ObjectFind(0,"TrailingStop") == -1)                    
   {
      ObjectCreate("TrailingStop", OBJ_HLINE, 0, 0, GridTS);                                                                   //  
      ObjectSet("TrailingStop", OBJPROP_COLOR, GridTScolor);
      ObjectSet("TrailingStop", OBJPROP_STYLE, TS_LINE_STYLE);            
      ObjectSetText("TrailingStop","TrailingStop");                        
   }
   if(GX_on && ObjectFind(0,"GX_Line") == -1)                    
   {
      ObjectCreate("GX_Line", OBJ_HLINE, 0, 0, GX_price);                                                                   //  
      ObjectSet("GX_Line", OBJPROP_COLOR, GX_Line_color);
      ObjectSet("GX_Line", OBJPROP_STYLE, GX_Line_STYLE);            
      ObjectSetText("GX_Line","GX_Line");                        
      ObjectSetInteger(0,"GX_Line",OBJPROP_SELECTABLE,false); 
   }
   if(GX_on && ObjectFind(0,"GX_Line_buy") == -1)                    
   {
      ObjectCreate("GX_Line_buy", OBJ_HLINE, 0, 0, GX_price_buy);                                                                   //  
      ObjectSet("GX_Line_buy", OBJPROP_COLOR, GX_Line_color_buy);
      ObjectSet("GX_Line_buy", OBJPROP_STYLE, GX_Line_STYLE);            
      ObjectSetText("GX_Line_buy","GX_Line_buy");                        
      ObjectSetInteger(0,"GX_Line_buy",OBJPROP_SELECTABLE,false); 
   }
   if(GX_on && ObjectFind(0,"GX_Line_sell") == -1)                    
   {
      ObjectCreate("GX_Line_sell", OBJ_HLINE, 0, 0, GX_price_sell);                                                                   //  
      ObjectSet("GX_Line_sell", OBJPROP_COLOR, GX_Line_color_sell);
      ObjectSet("GX_Line_sell", OBJPROP_STYLE, GX_Line_STYLE);            
      ObjectSetText("GX_Line_sell","GX_Line_sell");                        
      ObjectSetInteger(0,"GX_Line_sell",OBJPROP_SELECTABLE,false); 
   }
   
   if(Virt_Order_on && ObjectFind(0,"Virt_Order_SELL")==-1)
   {
      ObjectCreate("Virt_Order_SELL",OBJ_HLINE,0,0,0);
      ObjectSet("Virt_Order_SELL",OBJPROP_COLOR,Virt_Order_color);
      ObjectSet("Virt_Order_SELL",OBJPROP_STYLE,Virt_Order_LINE_STYLE);
      ObjectSetText("Virt_Order_SELL","âèðòóàëüíûé îðäåð");
   }
   if(Virt_Order_on && ObjectFind(0,"Virt_Order_BUY")==-1)
     {
      ObjectCreate("Virt_Order_BUY",OBJ_HLINE,0,0,0);
      ObjectSet("Virt_Order_BUY",OBJPROP_COLOR,Virt_Order_color);
      ObjectSet("Virt_Order_BUY",OBJPROP_STYLE,Virt_Order_LINE_STYLE);
      ObjectSetText("Virt_Order_BUY","âèðòóàëüíûé îðäåð");
     }

    if (qde_general >0 && openorders == 0)
       qde = qde_general;
    if (qdc_general >0)
       qdc = qdc_general;
    if(!fulltime)
    {
      if(curtime>=open1 && curtime<close1)
      { 
         if(qde1 >0)            qde = qde1;
         if(qdc1 >0)            qdc = qdc1;
      }   
      if(open2 >= close1 && curtime>=open2 && curtime<close2) 
      { 
         if(qde2 >0)            qde = qde2;
         if(qdc2 >0)            qdc = qdc2;
      }   
      if(open3 >= close2 && curtime>=open3 && curtime<close3)
      { 
         if(qde3 >0)            qde = qde3;
         if(qdc3 >0)            qdc = qdc3;
      }   
   }
   if(qde>0)
   {
      if (qde_price_var == 0 && qde_points > 0)
         qde_Line = qde_points/MP10D; 
      if (qde_price_var == 1 && qde_ATR_perc > 0)
      {
         bars_qde_ATR = iTime (NULL, qde_ATR_TF,1);
         qde_Line = percATR (qde_ATR_perc,qde_ATR_TF,qde_ATR_Period);
      }
      Quantum_op_buy    = iCustom(Symbol(),tf,"Quantum",qde,0,qde_oc);
      Quantum_op_sell   = iCustom(Symbol(),tf,"Quantum",qde,1,qde_oc);
   }
   if(qdc>0)
   {
      Quantum_cl_buy    = iCustom(Symbol(),tf,"Quantum",qdc,1,1);
      Quantum_cl_sell   = iCustom(Symbol(),tf,"Quantum",qdc,0,1);
   }
   if (Stochastic_op_on || Stochastic_cl_on)
   {
      bars_Stochastic_tf = iTime (NULL, Stochastic_tf,1);
      Stochastic_op = iStochastic(NULL,Stochastic_tf,Stochastic_K_op, Stochastic_D_op, Stochastic_S_op,MODE_SMA,0,MODE_MAIN,1);
      Stochastic_cl = iStochastic(NULL,Stochastic_tf,Stochastic_K_cl, Stochastic_D_cl, Stochastic_S_cl,MODE_SMA,0,MODE_MAIN,1);
   }
   if (Pfe_op_on || Pfe_cl_on)
   {
      bars_Pfe_tf = iTime (NULL, Pfe_tf,1);
      Pfe_op         =  iCustom(NULL,Pfe_tf,"PFE",Pfe_Period_op, Pfe_UseAvarage_op, Pfe_MaPeriod_op,Pfe_MODE_MA_op,0,1);
      Pfe_cl         =  iCustom(NULL,Pfe_tf,"PFE",Pfe_Period_cl, Pfe_UseAvarage_cl, Pfe_MaPeriod_cl,Pfe_MODE_MA_cl,0,1);
   }
   if (iMA_op_on)
   {
      bars_iMA_timeframe_op = iTime (NULL, iMA_timeframe_op,1);
      iMA_op = iMA(NULL,iMA_timeframe_op,iMA_ma_period_op, iMA_ma_shift_op, iMA_ma_method_op, iMA_applied_price_op,1);
   }
   if (iMA_cl_on)
   {
      bars_iMA_timeframe_cl = iTime (NULL, iMA_timeframe_cl,1);
      iMA_cl = iMA(NULL,iMA_timeframe_cl,iMA_ma_period_cl, iMA_ma_shift_cl, iMA_ma_method_cl, iMA_applied_price_cl,1);
   }
   if (MA_4H_op_on)
   {
      bars_MA_4H_timeframe_op = iTime (NULL,MA_4H_timeframe_op,1);
      MA_4H_level_0 = iMA(NULL,MA_4H_timeframe_op,MA_4H_ma_period_op, MA_4H_ma_shift_op, MA_4H_ma_method_op, MA_4H_applied_price_op,1);
      if (MA_4H_price_var == 0)
      {
         MA_4H_ATR_level_1 = MA_4H_level_1 / MP10D;
         MA_4H_ATR_level_2 = MA_4H_level_2 / MP10D;
      }
      if (MA_4H_price_var == 1)
      {
   
         bars_MA_4H_ATR_op            =  iTime(NULL,MA_4H_ATR_TF,1);
         MA_4H_ATR_level_1 = percATR(MA_4H_ATR_perc_level_1, MA_4H_ATR_TF, MA_4H_ATR_Period);   
         MA_4H_ATR_level_2 = percATR(MA_4H_ATR_perc_level_2, MA_4H_ATR_TF, MA_4H_ATR_Period);   
      }   
   }
   if (MACD_Xtr_on)
   {
      bars_MACD_Xtr_tf = iTime(NULL, MACD_Xtr_tf,1);
      MACD_Xtr_3 = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA,SlowMA,Source,SourcePeriod,BackPeriod,xVolatility,Sens, 3,1);
      MACD_Xtr_4 = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA,SlowMA,Source,SourcePeriod,BackPeriod,xVolatility,Sens, 4,1);
   }       
   if (MACD_Xtr_cl_on)
   {
      bars_MACD_Xtr_tf_cl = iTime(NULL, MACD_Xtr_tf,1);
      MACD_Xtr_3_cl = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA_cl,SlowMA_cl,Source_cl,SourcePeriod_cl,BackPeriod_cl,xVolatility_cl,Sens_cl, 3,1);
      MACD_Xtr_4_cl = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA_cl,SlowMA_cl,Source_cl,SourcePeriod_cl,BackPeriod_cl,xVolatility_cl,Sens_cl, 4,1);
   }
   if (Envelopes_on)
   {
      Envelopes_op_LO  = iEnvelopes(NULL,Envelopes_tf,MA_Period,MA_Method,MA_Shift,Applied_Price,Deviation,MODE_LOWER,1);
      Envelopes_op_UP = iEnvelopes(NULL,Envelopes_tf,MA_Period,MA_Method,MA_Shift,Applied_Price,Deviation,MODE_UPPER,1);
      bars_Envelopes_tf = iTime(NULL, Envelopes_tf,1);
   }
   if (Envelopes_cl_on)
   {
      Envelopes_cl_UP  = iEnvelopes(NULL,Envelopes_tf,MA_Period_cl,MA_Method_cl,MA_Shift_cl,Applied_Price_cl,Deviation_cl,MODE_UPPER,1);
      Envelopes_cl_LO = iEnvelopes(NULL,Envelopes_tf,MA_Period_cl,MA_Method_cl,MA_Shift_cl,Applied_Price_cl,Deviation_cl,MODE_LOWER,1);
      bars_Envelopes_tf_cl = iTime(NULL, Envelopes_tf,1);
   }
   if (ATR_Channels_op_on)
   {
      ATR_op_1 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_on,ATR_MA_Periods_on,ATR_MA_type_on,ATR_Mult_Factor1_on,ATR_applied_price_on,ATR_fontsize_on,1,1);   
      ATR_op_0 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_on,ATR_MA_Periods_on,ATR_MA_type_on,ATR_Mult_Factor1_on,ATR_applied_price_on,ATR_fontsize_on,0,1);   
      bars_ATR_tf = iTime(NULL,ATR_tf, 1);
   }
   if (ATR_Channels_cl_on)
   {
      ATR_cl_1 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_cl,ATR_MA_Periods_cl,ATR_MA_type_cl,ATR_Mult_Factor1_cl,ATR_applied_price_cl,ATR_fontsize_cl,1,1);   
      ATR_cl_0 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_cl,ATR_MA_Periods_cl,ATR_MA_type_cl,ATR_Mult_Factor1_cl,ATR_applied_price_cl,ATR_fontsize_cl,0,1);   
      bars_ATR_tf_cl = iTime(NULL,ATR_tf, 1);
   }
   if (ChannelsFIBO_MTF_AD_EA_on)
   {
      switch ( int (i_fiboLevel1) )
      {                                       
         case -1: i_fiboLevel1  = 23.6; break;   // 23.6              
         case -2: i_fiboLevel1  = 38.2; break;   // 38.2          
         case -3: i_fiboLevel1  = 50.0; break;   // 50           
         case -4: i_fiboLevel1  = 61.8; break;   // 61.8 
         case -5: i_fiboLevel1  = 78.6; break;   // 78.6          
         case -6: i_fiboLevel1  = 82.87; break;   // Gann 82.87 
         case -7: i_fiboLevel1  = 88.2; break;   // 88.2               
         case -8: i_fiboLevel1  = 100.0; break;   // 100.0
      }
      bars_ChannelsFIBO_MTF_tf = iTime(NULL, i_tf, 1);
      ChannelsFIBO_MTF_op_0 = iCustom(NULL,i_tf,"ChannelsFIBO_MTF_AD_EA",i_tf,i_extremumDepth,i_maPeriod,i_maMethod,i_maPrice,i_fiboLevel1,i_indBarsCount,0,1);
      ChannelsFIBO_MTF_op_1 = iCustom(NULL,i_tf,"ChannelsFIBO_MTF_AD_EA",i_tf,i_extremumDepth,i_maPeriod,i_maMethod,i_maPrice,i_fiboLevel1,i_indBarsCount,1,1);
   }
   if (ChannelsFIBO_MTF_AD_EA_cl_on)
   {
      switch ( int (i_fiboLevel1_cl) )
      {                                       
         case -1: i_fiboLevel1_cl  = 23.6; break;   // 23.6              
         case -2: i_fiboLevel1_cl  = 38.2; break;   // 38.2          
         case -3: i_fiboLevel1_cl  = 50.0; break;   // 50           
         case -4: i_fiboLevel1_cl  = 61.8; break;   // 61.8 
         case -5: i_fiboLevel1_cl  = 78.6; break;   // 78.6          
         case -6: i_fiboLevel1_cl  = 82.87; break;   // Gann 82.87 
         case -7: i_fiboLevel1_cl  = 88.2; break;   // 88.2               
         case -8: i_fiboLevel1_cl  = 100.0; break;   // 100.0
      }     
      bars_ChannelsFIBO_MTF_cl_tf = iTime(NULL, i_tf_cl, 1);
      ChannelsFIBO_MTF_cl_0 = iCustom(NULL,i_tf_cl,"ChannelsFIBO_MTF_AD_EA",i_tf_cl,i_extremumDepth_cl,i_maPeriod_cl,i_maMethod_cl,i_maPrice_cl,i_fiboLevel1_cl,i_indBarsCount_cl,0,1);
      ChannelsFIBO_MTF_cl_1 = iCustom(NULL,i_tf_cl,"ChannelsFIBO_MTF_AD_EA",i_tf_cl,i_extremumDepth_cl,i_maPeriod_cl,i_maMethod_cl,i_maPrice_cl,i_fiboLevel1_cl,i_indBarsCount_cl,1,1);
   }
   if (ChannelsFIBO_v2_MTF_AD_EA_on)
   {
      switch ( int(i_fiboLevel1_v2 ))
      {                                       
         case -1: i_fiboLevel1_v2  = 23.6; break;   // 23.6              
         case -2: i_fiboLevel1_v2  = 38.2; break;   // 38.2          
         case -3: i_fiboLevel1_v2  = 50.0; break;   // 50           
         case -4: i_fiboLevel1_v2  = 61.8; break;   // 61.8 
         case -5: i_fiboLevel1_v2  = 78.6; break;   // 78.6          
         case -6: i_fiboLevel1_v2  = 82.87; break;   // Gann 82.87 
         case -7: i_fiboLevel1_v2  = 88.2; break;   // 88.2               
         case -8: i_fiboLevel1_v2  = 100.0; break;   // 100.0
      }  
      bars_ChannelsFIBO_v2_tf = iTime(NULL, i_tf_v2, 1);
      ChannelsFIBO_v2_op_0 = iCustom(NULL,i_tf_v2,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2,i_extremumDepth_v2,i_maPeriod_v2,i_maMethod_v2,i_maPrice_v2,i_fiboLevel1_v2,i_shiftMethod_v2,i_indBarsCount_v2,0,1);
      ChannelsFIBO_v2_op_1 = iCustom(NULL,i_tf_v2,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2,i_extremumDepth_v2,i_maPeriod_v2,i_maMethod_v2,i_maPrice_v2,i_fiboLevel1_v2,i_shiftMethod_v2,i_indBarsCount_v2,1,1);
   }
   if (ChannelsFIBO_v2_MTF_AD_EA_cl_on)
   {
      switch ( int(i_fiboLevel1_v2_cl ))
      {                                       
         case -1: i_fiboLevel1_v2_cl  = 23.6; break;   // 23.6              
         case -2: i_fiboLevel1_v2_cl  = 38.2; break;   // 38.2          
         case -3: i_fiboLevel1_v2_cl  = 50.0; break;   // 50           
         case -4: i_fiboLevel1_v2_cl  = 61.8; break;   // 61.8 
         case -5: i_fiboLevel1_v2_cl  = 78.6; break;   // 78.6          
         case -6: i_fiboLevel1_v2_cl  = 82.87; break;   // Gann 82.87 
         case -7: i_fiboLevel1_v2_cl  = 88.2; break;   // 88.2               
         case -8: i_fiboLevel1_v2_cl  = 100.0; break;   // 100.0
      }      
      bars_ChannelsFIBO_v2_cl_tf = iTime(NULL, i_tf_v2_cl, 1);
      ChannelsFIBO_v2_cl_0 = iCustom(NULL,i_tf_v2_cl,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2_cl,i_extremumDepth_v2_cl,i_maPeriod_v2_cl,i_maMethod_v2_cl,i_maPrice_v2_cl,i_fiboLevel1_v2_cl,i_shiftMethod_v2_cl,i_indBarsCount_v2_cl,0,1);
      ChannelsFIBO_v2_cl_1 = iCustom(NULL,i_tf_v2_cl,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2_cl,i_extremumDepth_v2_cl,i_maPeriod_v2_cl,i_maMethod_v2_cl,i_maPrice_v2_cl,i_fiboLevel1_v2_cl,i_shiftMethod_v2_cl,i_indBarsCount_v2_cl,1,1);
   }
   if (Envelopes_on)
   {
      bars_Envelopes_tf = iTime(NULL, Envelopes_tf, 1);
      double Envelopes_MA = iMA(Symbol(),Envelopes_tf, MA_Period, MA_Shift, MA_Method, Applied_Price,1);
      switch ( int( Deviation ))
      {                                       
         case -1: Deviation  = 0.23* Envelopes_MA; break;   // 23.6              
         case -2: Deviation  = 0.38* Envelopes_MA; break;   // 38.2          
         case -3: Deviation  = 0.50* Envelopes_MA; break;   // 50           
         case -4: Deviation  = 0.62* Envelopes_MA; break;   // 61.8 
         case -5: Deviation  = 0.78* Envelopes_MA; break;   // 78.6          
         case -6: Deviation  = 0.83* Envelopes_MA; break;   // Gann 82.87 
         case -7: Deviation  = 0.88* Envelopes_MA; break;   // 88.2               
      }
   }           
   if (Envelopes_cl_on)
   {
      bars_Envelopes_tf_cl = iTime(NULL, Envelopes_tf, 1);      
      double Envelopes_MA_cl = iMA(Symbol(),Envelopes_tf, MA_Period_cl, MA_Shift_cl, MA_Method_cl, Applied_Price_cl,1);
      switch ( int( Deviation_cl ))
      {                                       
         case -1: Deviation_cl  = 0.23* Envelopes_MA_cl; break;   // 23.6              
         case -2: Deviation_cl  = 0.38* Envelopes_MA_cl; break;   // 38.2          
         case -3: Deviation_cl  = 0.50* Envelopes_MA_cl; break;   // 50           
         case -4: Deviation_cl  = 0.62* Envelopes_MA_cl; break;   // 61.8 
         case -5: Deviation_cl  = 0.78* Envelopes_MA_cl; break;   // 78.6          
         case -6: Deviation_cl  = 0.83* Envelopes_MA_cl; break;   // Gann 82.87 
         case -7: Deviation_cl  = 0.88* Envelopes_MA_cl; break;   // 88.2               
      }    
   }
     
   return(0);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double OnTester() 
{
  return(GetRecoveryFactor());
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int deinit()
  {
   DeleteLines();
   ObjectDelete(0,"start");
   ObjectDelete(0,"manual"); 
   ObjectDelete(0,"GX_Line");
   ObjectDelete(0,"GX_Line_buy");
   ObjectDelete(0,"GX_Line_sell");
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
{
   if (!IsTesting() || (indivsl > 0 || indivtp > 0))
   {
      countbuy    = CountTrades (OP_BUY);
      countsell   = CountTrades (OP_SELL);
      openorders = countbuy + countsell;
      if(openorders <= 0)
         prevorderprice =0;
      if(openorders > 0 && openorders_old != openorders)
      {
         openorders_old = openorders;
         Prevorderprice();
         Lastorderbar();
      }      
   }      
//if(Digits==5 || Digits==3)
//  {
//   digits=1;
//  }
   if(CT==0)curtime=TimeCurrent();
   else     curtime=TimeGMT();

   if(debug && !IsTradeAllowed())
     Alert("Broker does not allow EA to trade");

   if(iTime(Symbol(),PERIOD_D1,0)>prevday) 
   {
      prevday=iTime(Symbol(),PERIOD_D1,0);
      cycles=0;
      c1=0;
      c2=0;
      c3=0;
      if (!fulltime)
      {
         open1=StrToTime(StringConcatenate(IntegerToString(open1hour,2,'0'),":",IntegerToString(open1minut,2,'0')));
         close1=StrToTime(StringConcatenate(IntegerToString(close1hour,2,'0'),":",IntegerToString(close1minut,2,'0')));
         open2=StrToTime(StringConcatenate(IntegerToString(open2hour,2,'0'),":",IntegerToString(open2minut,2,'0')));
         close2=StrToTime(StringConcatenate(IntegerToString(close2hour,2,'0'),":",IntegerToString(close2minut,2,'0')));
         open3=StrToTime(StringConcatenate(IntegerToString(open3hour,2,'0'),":",IntegerToString(open3minut,2,'0')));
         close3=StrToTime(StringConcatenate(IntegerToString(close3hour,2,'0'),":",IntegerToString(close3minut,2,'0')));
      }
      if (NC_on)
      {
         NC_1  =  StrToTime(StringConcatenate(IntegerToString(NC_1_hour,   2,'0'),":",IntegerToString(NC_1_minut, 2,'0')));
         NC_2  =  StrToTime(StringConcatenate(IntegerToString(NC_2_hour,   2,'0'),":",IntegerToString(NC_2_minut, 2,'0')));
      }
      if (GX_on && GX_price_var < 2)
      {
         GX_time = StrToTime(StringConcatenate(IntegerToString(GX_hour,   2,'0'),":",IntegerToString(GX_minut, 2,'0')));
         GX_price = 0;
         GX_price_buy = 0;
         GX_price_sell = 0;
      }
   }
   
   if (!fulltime && Virt_Order_on
      && (  (curtime < open1 && open1 > 0)
         || ((curtime > close1) && ((curtime < open2) || (open2 - close1 < 0)) && (close1-open1)>0)
         || ((curtime > close2) && ((curtime < open3) || (open3 - close2 < 0)) && (close2-open2)>0)
         || ((curtime > close3) && (close3 - open3) > 0)
         )
      )   
   {
      if (countbuy <= 0)
      {
         Virt_Order_buy = 0;
         ObjectSet("Virt_Order_BUY",OBJPROP_PRICE1,Virt_Order_buy);
      }
      if (countsell <= 0)
      {
         Virt_Order_sell = 0;
         ObjectSet("Virt_Order_SELL",OBJPROP_PRICE1,Virt_Order_sell);
      }
   }
   // òðàë âèðòóàëüíîãî îðäåðà   
   if(Virt_Order_buy>0 && Ask<Virt_Order_buy-Virt_Order_dist)
   {
      Virt_Order_buy=Ask+Virt_Order_dist;
      ObjectSet("Virt_Order_BUY",OBJPROP_PRICE1,Virt_Order_buy);
   }
   if(Virt_Order_sell>0 && Bid>Virt_Order_sell+Virt_Order_dist)
   {
      Virt_Order_sell=Bid-Virt_Order_dist;
      ObjectSet("Virt_Order_SELL",OBJPROP_PRICE1,Virt_Order_sell);
   }
   if(Virt_Order_buy>0 && Ask>Virt_Order_buy)// && openorders==0)
   {
      if (countsell >0)
      { 
         if (Virt_TS_on)
            CloseNormal();   
         Virt_Order_buy=0;
         ObjectSet("Virt_Order_BUY",OBJPROP_PRICE1,Virt_Order_buy);
      }
      if (countsell == 0)
      {
         lots=GetLots(Ask,"Buy");
         OpenOrder(OP_BUY);
      }
   }
   if(Virt_Order_sell>0 && Bid<Virt_Order_sell)// && openorders==0)
   {
      if (countbuy >0)
      {
         if (Virt_TS_on)
            CloseNormal();   
         Virt_Order_sell=0;
         ObjectSet("Virt_Order_SELL",OBJPROP_PRICE1,Virt_Order_sell);
      }
      if (countbuy == 0)
      {
         lots=GetLots(Bid,"Sell");
         OpenOrder(OP_SELL);
      }
   }   
   if (GridTSon > 0 && iTime(NULL,TF_ATR,1)> bars_TS_ATR)
   {
      bars_TS_ATR = iTime(NULL,TF_ATR,1);
      TS_ATR=percATR (percTS_ATR,TF_ATR,ATR_Period);
      TSstep_ATR=percATR(percTSstep_ATR,TF_ATR, ATR_Period)/MathPow(openorders+1,TS_ATR_ED);   
   }
   if (GX_on && GX_price_var <2)
   {
      if (GX_price <= 0 && curtime >= GX_time)
         GX_Price();
      if(ObjectFind(0,"GX_Line") == -1)                    
      {
         ObjectCreate("GX_Line", OBJ_HLINE, 0, 0, GX_price);                                                                   //  
         ObjectSet("GX_Line", OBJPROP_COLOR, GX_Line_color);
         ObjectSet("GX_Line", OBJPROP_STYLE, GX_Line_STYLE);            
         ObjectSetText("GX_Line","GX_Line");                        
      }
      else   
         ObjectSet("GX_Line", OBJPROP_PRICE1, GX_price);
      if(ObjectFind(0,"GX_Line_buy") == -1)                    
      {
         ObjectCreate("GX_Line_buy", OBJ_HLINE, 0, 0, GX_price_buy);                                                                   //  
         ObjectSet("GX_Line_buy", OBJPROP_COLOR, GX_Line_color_buy);
         ObjectSet("GX_Line_buy", OBJPROP_STYLE, GX_Line_STYLE);            
         ObjectSetText("GX_Line_buy","GX_Line_buy");                        
      }
      else
         ObjectSet("GX_Line_buy", OBJPROP_PRICE1, GX_price_buy);
      if(ObjectFind(0,"GX_Line_sell") == -1)                    
      {
         ObjectCreate("GX_Line_sell", OBJ_HLINE, 0, 0, GX_price_sell);                                                                   //  
         ObjectSet("GX_Line_sell", OBJPROP_COLOR, GX_Line_color_sell);
         ObjectSet("GX_Line_sell", OBJPROP_STYLE, GX_Line_STYLE);            
         ObjectSetText("GX_Line_sell","GX_Line_sell");                        
         ObjectSetInteger(0,"GX_Line_sell",OBJPROP_SELECTABLE,true); 
      }
      else   
         ObjectSet("GX_Line_sell", OBJPROP_PRICE1, GX_price_sell);
   }   
   if(CP_ATR_perc >0 && CP_ATR_Period>0 && iTime (NULL, CP_ATR_TF,1) > bars_CP_ATR)
   {
      bars_CP_ATR = iTime (NULL, CP_ATR_TF,1);
      CP_ATR = percATR (CP_ATR_perc,CP_ATR_TF,CP_ATR_Period)*MP10D/MathPow(openorders+1, CP_ATR_ED);
      if((Slip_on == 2 || Slip_on == 3) && CP_ATR < Slip_cl)
         CP_ATR = Slip_cl;
   }
   if (Virt_Order_on && iTime(NULL, Virt_Order_TF, 1) > bars_Virt_Order)
   { 
      bars_Virt_Order = iTime(NULL, Virt_Order_TF, 1);
      Virt_Order_dist=percATR(Virt_Order_dist_perc,Virt_Order_TF,Virt_Order_Period);
   }
   if ((qde > 0 || qdc > 0) && iTime(NULL, tf, 1) > bars)
   {
      if (qde_general >0 && openorders == 0)
         qde = qde_general;
      if (qdc_general >0)
         qdc = qdc_general;
      if(!fulltime)
      {
         if(curtime>=open1 && curtime<close1)
         {
            if(qde1 >0)
               qde = qde1;
            if(qdc1 >0)
               qdc = qdc1;
         }
         if(open2 >= close1 && curtime>=open2 && curtime<close2)
         {
            if(qde2 >0)
               qde = qde2;
            if(qdc2 >0)
               qdc = qdc2;
         }
         if(open3 >= close2 && curtime>=open3 && curtime<close3)
         {
            if(qde3 >0)
               qde = qde3;
            if(qdc3 >0)
               qdc = qdc3;
         }
      }      
      bars = iTime(NULL, tf, 1);
      barNext = true;
      if (qde_price_var == 1 && qde_ATR_perc > 0 && iTime (NULL, qde_ATR_TF,1) > bars_qde_ATR)
      {
         bars_qde_ATR = iTime (NULL, qde_ATR_TF,1);
         qde_Line = percATR (qde_ATR_perc,qde_ATR_TF,qde_ATR_Period);
      }
      qde_bars_count_buy--;
      Quantum_op_buy    =  iCustom(Symbol(),tf,"Quantum",qde,0,qde_oc);
      if(Quantum_op_buy > 0)
      {
         if(qde_Line > 0 || qde_bars > 0)
         { 
            ObjectDelete("Quantum_buy");                                                                  
            if(qde_Line == 0 && qde_bars > 0)
               ObjectCreate("Quantum_buy", OBJ_RECTANGLE, 0, iTime(NULL,tf,0), 0, 2 * iTime(NULL,tf,0) - iTime(NULL,tf,qde_bars), 1000);                                                                   //  
            if(qde_Line > 0 && qde_bars == 0)
               ObjectCreate("Quantum_buy", OBJ_RECTANGLE, 0, 0, Quantum_op_buy, 2 * iTime(NULL,tf,0), Quantum_op_buy + qde_Line);                                                                   //  
            if(qde_Line > 0 && qde_bars > 0)
               ObjectCreate("Quantum_buy", OBJ_RECTANGLE, 0, iTime(NULL,tf,0), Quantum_op_buy, 2 * iTime(NULL,tf,0) - iTime(NULL,tf,qde_bars), Quantum_op_buy + qde_Line);                                                                   //  
            ObjectSet("Quantum_buy", OBJPROP_COLOR, qde_Line_color_buy);
            ObjectSet("Quantum_buy", OBJPROP_BACK, true);            
         }
         qde_bars_count_buy    =  qde_bars;
      }
      if(Quantum_op_buy <= 0)
         if (  (qde_Line == 0 && qde_bars > 0 && qde_bars_count_buy >= 0)
            || (qde_bars <= 0 && qde_Line > 0 && High[1] < ObjectGet("Quantum_buy",OBJPROP_PRICE2))
            || (qde_bars > 0 && qde_bars_count_buy >= 0 && qde_Line > 0 && High[1] < ObjectGet("Quantum_buy",OBJPROP_PRICE2))
            )
            Quantum_op_buy = 1;
         else
            ObjectDelete("Quantum_buy");                                                                   //  
      qde_bars_count_sell--;
      Quantum_op_sell   = iCustom(Symbol(),tf,"Quantum",qde,1,qde_oc);
      if(Quantum_op_sell > 0)
      {
         if(qde_Line > 0 || qde_bars > 0)
         {
            ObjectDelete("Quantum_sell");                                                                   //  
            if(qde_Line == 0 && qde_bars > 0)
               ObjectCreate("Quantum_sell", OBJ_RECTANGLE, 0, iTime(NULL,tf,0), 0, 2 * iTime(NULL,tf,0) - iTime(NULL,tf,qde_bars), 1000);                                                                   //  
            if(qde_Line > 0 && qde_bars == 0)
               ObjectCreate("Quantum_sell", OBJ_RECTANGLE, 0, 0, Quantum_op_sell, 2 * iTime(NULL,tf,0), Quantum_op_sell - qde_Line);                                                                   //  
            if(qde_Line > 0 && qde_bars > 0)
               ObjectCreate("Quantum_sell", OBJ_RECTANGLE, 0, iTime(NULL,tf,0), Quantum_op_sell, 2* iTime(NULL,tf,0) - iTime(NULL,tf,qde_bars), Quantum_op_sell - qde_Line);                                                                   //  
            ObjectSet("Quantum_sell", OBJPROP_COLOR, qde_Line_color_sell);
            ObjectSet("Quantum_sell", OBJPROP_BACK, true);            
         }
         qde_bars_count_sell    =  qde_bars;
      }
      if(Quantum_op_sell <= 0)
         if (  (qde_Line == 0 && qde_bars > 0 && qde_bars_count_sell >= 0)
            || (qde_bars <= 0 && qde_Line > 0 && Low[1] > ObjectGet("Quantum_sell",OBJPROP_PRICE2))
            || (qde_bars > 0 && qde_bars_count_sell >= 0 && qde_Line > 0 && Low[1] > ObjectGet("Quantum_sell",OBJPROP_PRICE2))
            )
            Quantum_op_sell = 1;
         else
            ObjectDelete("Quantum_sell");                                                                   //  
      if(qdc > 0)
      {
         Quantum_cl_buy    = iCustom(Symbol(),tf,"Quantum",qdc,1,1);
         Quantum_cl_sell   = iCustom(Symbol(),tf,"Quantum",qdc,0,1);
      }
      if (openorders > 0)
         lastorderbar++;
   }
   if(barNext && qde_oc==0)
   {
      Quantum_op_buy    = iCustom(Symbol(),tf,"Quantum",qde,0,0);
      Quantum_op_sell   = iCustom(Symbol(),tf,"Quantum",qde,1,0);
   }         
   if ((Stochastic_op_on || Stochastic_cl_on) && iTime(NULL,Stochastic_tf,1) >  bars_Stochastic_tf)
   {
      bars_Stochastic_tf = iTime (NULL, Stochastic_tf,1);   
      Stochastic_op = iStochastic(NULL,Stochastic_tf,Stochastic_K_op, Stochastic_D_op, Stochastic_S_op,MODE_SMA,0,MODE_MAIN,1);
      Stochastic_cl = iStochastic(NULL,Stochastic_tf,Stochastic_K_cl, Stochastic_D_cl, Stochastic_S_cl,MODE_SMA,0,MODE_MAIN,1);
   }
   if ((Pfe_op_on || Pfe_cl_on) && iTime (NULL, Pfe_tf,1) > bars_Pfe_tf)
   {
      bars_Pfe_tf = iTime (NULL, Pfe_tf,1);
      Pfe_op         =  iCustom(NULL,Pfe_tf,"PFE",Pfe_Period_op, Pfe_UseAvarage_op, Pfe_MaPeriod_op,Pfe_MODE_MA_op,0,1);
      Pfe_cl         =  iCustom(NULL,Pfe_tf,"PFE",Pfe_Period_cl, Pfe_UseAvarage_cl, Pfe_MaPeriod_cl,Pfe_MODE_MA_cl,0,1);
   }
   if (iMA_op_on && iTime(NULL,iMA_timeframe_op,1) >  bars_iMA_timeframe_op)
   {
      bars_iMA_timeframe_op = iTime (NULL, iMA_timeframe_op,1);
      iMA_op = iMA(NULL,iMA_timeframe_op,iMA_ma_period_op, iMA_ma_shift_op, iMA_ma_method_op, iMA_applied_price_op,1);
   }
   if (iMA_cl_on &&iTime (NULL, iMA_timeframe_cl,1)>bars_iMA_timeframe_cl)
   {
      bars_iMA_timeframe_cl = iTime (NULL, iMA_timeframe_cl,1);
      iMA_cl = iMA(NULL,iMA_timeframe_cl,iMA_ma_period_cl, iMA_ma_shift_cl, iMA_ma_method_cl, iMA_applied_price_cl,1);
   }
   if (MA_4H_op_on)
   { 
      if (iTime (NULL,MA_4H_timeframe_op,1) > bars_MA_4H_timeframe_op)
      {
         bars_MA_4H_timeframe_op = iTime (NULL,MA_4H_timeframe_op,1);
         MA_4H_level_0 = iMA(NULL,MA_4H_timeframe_op,MA_4H_ma_period_op, MA_4H_ma_shift_op, MA_4H_ma_method_op, MA_4H_applied_price_op,1);
         if (MA_4H_price_var == 0)
         {
            MA_4H_ATR_level_1 = MA_4H_level_1 / MP10D;
            MA_4H_ATR_level_2 = MA_4H_level_2 / MP10D;
         }
      }   
      if (MA_4H_price_var == 1 && iTime(NULL,MA_4H_ATR_TF,1) > bars_MA_4H_ATR_op)
      {
         bars_MA_4H_ATR_op            =  iTime(NULL,MA_4H_ATR_TF,1);
         MA_4H_ATR_level_1 = percATR(MA_4H_ATR_perc_level_1, MA_4H_ATR_TF, MA_4H_ATR_Period);   
         MA_4H_ATR_level_2 = percATR(MA_4H_ATR_perc_level_2, MA_4H_ATR_TF, MA_4H_ATR_Period);   
      }   
   }
   if (MACD_Xtr_on && iTime(NULL, MACD_Xtr_tf,1) > bars_MACD_Xtr_tf)
   {
      bars_MACD_Xtr_tf = iTime(NULL, MACD_Xtr_tf,1);
      MACD_Xtr_3 = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA,SlowMA,Source,SourcePeriod,BackPeriod,xVolatility,Sens, 3,1);
      MACD_Xtr_4 = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA,SlowMA,Source,SourcePeriod,BackPeriod,xVolatility,Sens, 4,1);
   }      
   if (MACD_Xtr_cl_on && iTime(NULL, MACD_Xtr_tf,1) > bars_MACD_Xtr_tf_cl)
   {
      bars_MACD_Xtr_tf_cl = iTime(NULL, MACD_Xtr_tf,1);
      MACD_Xtr_3_cl = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA_cl,SlowMA_cl,Source_cl,SourcePeriod_cl,BackPeriod_cl,xVolatility_cl,Sens_cl, 3,1);
      MACD_Xtr_4_cl = iCustom(NULL,MACD_Xtr_tf,"_MACD_Xtr",FastMA_cl,SlowMA_cl,Source_cl,SourcePeriod_cl,BackPeriod_cl,xVolatility_cl,Sens_cl, 4,1);
   }      
   if(MA_Kiosotto_op_on && iTime(NULL,MA_Kiosotto_tf_op,1)>bars_MA_Kiosotto_tf_op)
   {
      bars_MA_Kiosotto_tf_op=iTime(NULL,MA_Kiosotto_tf_op,1);
      MA_Kiosotto_MA_op=iCustom(NULL,MA_Kiosotto_tf_op,"Kiosotto_Lines_MA",MA_Kiosotto_i_dev_period_op,MA_Kiosotto_MA_Period_op, MA_Kiosotto_i_maMethod_op,MA_Kiosotto_g_shift_op,MA_Kiosotto_i_useAlert_op,MA_Kiosotto_i_indBarsCount_op,2,1);
      MA_Kiosotto_op_buy=iCustom(NULL,MA_Kiosotto_tf_op,"Kiosotto_Lines_MA",MA_Kiosotto_i_dev_period_op,MA_Kiosotto_MA_Period_op, MA_Kiosotto_i_maMethod_op,MA_Kiosotto_g_shift_op,MA_Kiosotto_i_useAlert_op,MA_Kiosotto_i_indBarsCount_op,1,1);
      MA_Kiosotto_op_sell=iCustom(NULL,MA_Kiosotto_tf_op,"Kiosotto_Lines_MA",MA_Kiosotto_i_dev_period_op,MA_Kiosotto_MA_Period_op, MA_Kiosotto_i_maMethod_op,MA_Kiosotto_g_shift_op,MA_Kiosotto_i_useAlert_op,MA_Kiosotto_i_indBarsCount_op,0,1);
   }
   if(MA_Kiosotto_cl_on && iTime(NULL,MA_Kiosotto_tf_cl,1)>bars_MA_Kiosotto_tf_cl)
   {
      bars_MA_Kiosotto_tf_cl=iTime(NULL,MA_Kiosotto_tf_cl,1);
      MA_Kiosotto_MA_cl=iCustom(NULL,MA_Kiosotto_tf_cl,"Kiosotto_Lines_MA",MA_Kiosotto_i_dev_period_cl,MA_Kiosotto_MA_Period_cl, MA_Kiosotto_i_maMethod_cl,MA_Kiosotto_g_shift_cl,MA_Kiosotto_i_useAlert_cl,MA_Kiosotto_i_indBarsCount_cl,2,1);
      MA_Kiosotto_cl_buy=iCustom(NULL,MA_Kiosotto_tf_cl,"Kiosotto_Lines_MA",MA_Kiosotto_i_dev_period_cl,MA_Kiosotto_MA_Period_cl, MA_Kiosotto_i_maMethod_cl,MA_Kiosotto_g_shift_cl,MA_Kiosotto_i_useAlert_cl,MA_Kiosotto_i_indBarsCount_cl,0,1);
      MA_Kiosotto_cl_sell=iCustom(NULL,MA_Kiosotto_tf_cl,"Kiosotto_Lines_MA",MA_Kiosotto_i_dev_period_cl,MA_Kiosotto_MA_Period_cl, MA_Kiosotto_i_maMethod_cl,MA_Kiosotto_g_shift_cl,MA_Kiosotto_i_useAlert_cl,MA_Kiosotto_i_indBarsCount_cl,1,1);
   }
   if (Envelopes_on && iTime (NULL, Envelopes_tf,1) > bars_Envelopes_tf)
   {
      Envelopes_op_LO  = iEnvelopes(NULL,Envelopes_tf,MA_Period,MA_Method,MA_Shift,Applied_Price,Deviation,MODE_LOWER,1);
      Envelopes_op_UP = iEnvelopes(NULL,Envelopes_tf,MA_Period,MA_Method,MA_Shift,Applied_Price,Deviation,MODE_UPPER,1);
      bars_Envelopes_tf = iTime(NULL, Envelopes_tf,1);
   }
   if (Envelopes_cl_on && iTime (NULL, Envelopes_tf,1) > bars_Envelopes_tf_cl)
   {
      Envelopes_cl_UP  = iEnvelopes(NULL,Envelopes_tf,MA_Period_cl,MA_Method_cl,MA_Shift_cl,Applied_Price_cl,Deviation_cl,MODE_UPPER,1);
      Envelopes_cl_LO = iEnvelopes(NULL,Envelopes_tf,MA_Period_cl,MA_Method_cl,MA_Shift_cl,Applied_Price_cl,Deviation_cl,MODE_LOWER,1);
      bars_Envelopes_tf_cl = iTime(NULL, Envelopes_tf,1);
   }
   if (ChannelsFIBO_MTF_AD_EA_on && iTime (NULL, i_tf,1) > bars_ChannelsFIBO_MTF_tf)
   {
      bars_ChannelsFIBO_MTF_tf = iTime(NULL, i_tf, 1);
      ChannelsFIBO_MTF_op_0 = iCustom(NULL,i_tf,"ChannelsFIBO_MTF_AD_EA",i_tf,i_extremumDepth,i_maPeriod,i_maMethod,i_maPrice,i_fiboLevel1,i_indBarsCount,0,1);
      ChannelsFIBO_MTF_op_1 = iCustom(NULL,i_tf,"ChannelsFIBO_MTF_AD_EA",i_tf,i_extremumDepth,i_maPeriod,i_maMethod,i_maPrice,i_fiboLevel1,i_indBarsCount,1,1);
   }      
   if (ChannelsFIBO_MTF_AD_EA_cl_on && iTime (NULL, i_tf_cl,1) > bars_ChannelsFIBO_MTF_cl_tf)
   {
      bars_ChannelsFIBO_MTF_cl_tf = iTime(NULL, i_tf_cl, 1);
      ChannelsFIBO_MTF_cl_0 = iCustom(NULL,i_tf_cl,"ChannelsFIBO_MTF_AD_EA",i_tf_cl,i_extremumDepth_cl,i_maPeriod_cl,i_maMethod_cl,i_maPrice_cl,i_fiboLevel1_cl,i_indBarsCount_cl,0,1);
      ChannelsFIBO_MTF_cl_1 = iCustom(NULL,i_tf_cl,"ChannelsFIBO_MTF_AD_EA",i_tf_cl,i_extremumDepth_cl,i_maPeriod_cl,i_maMethod_cl,i_maPrice_cl,i_fiboLevel1_cl,i_indBarsCount_cl,1,1);
   }   
   if (ChannelsFIBO_v2_MTF_AD_EA_on && iTime (NULL, i_tf_v2,1) > bars_ChannelsFIBO_v2_tf)
   {
      bars_ChannelsFIBO_v2_tf = iTime(NULL, i_tf_v2, 1);
      ChannelsFIBO_v2_op_0 = iCustom(NULL,i_tf_v2,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2,i_extremumDepth_v2,i_maPeriod_v2,i_maMethod_v2,i_maPrice_v2,i_fiboLevel1_v2,i_shiftMethod_v2,i_indBarsCount_v2,0,1);
      ChannelsFIBO_v2_op_1 = iCustom(NULL,i_tf_v2,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2,i_extremumDepth_v2,i_maPeriod_v2,i_maMethod_v2,i_maPrice_v2,i_fiboLevel1_v2,i_shiftMethod_v2,i_indBarsCount_v2,1,1);
   }
   if (ChannelsFIBO_v2_MTF_AD_EA_cl_on && iTime (NULL, i_tf_v2_cl,1) > bars_ChannelsFIBO_v2_cl_tf)
   {
      bars_ChannelsFIBO_v2_cl_tf = iTime(NULL, i_tf_v2_cl, 1);
      ChannelsFIBO_v2_cl_0 = iCustom(NULL,i_tf_v2_cl,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2_cl,i_extremumDepth_v2_cl,i_maPeriod_v2_cl,i_maMethod_v2_cl,i_maPrice_v2_cl,i_fiboLevel1_v2_cl,i_shiftMethod_v2_cl,i_indBarsCount_v2_cl,0,1);
      ChannelsFIBO_v2_cl_1 = iCustom(NULL,i_tf_v2_cl,"ChannelsFIBO_v2_MTF_AD_EA",i_tf_v2_cl,i_extremumDepth_v2_cl,i_maPeriod_v2_cl,i_maMethod_v2_cl,i_maPrice_v2_cl,i_fiboLevel1_v2_cl,i_shiftMethod_v2_cl,i_indBarsCount_v2_cl,1,1);
   }   
   if (ATR_Channels_op_on && iTime (NULL, ATR_tf,1) > bars_ATR_tf)
   {
      ATR_op_1 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_on,ATR_MA_Periods_on,ATR_MA_type_on,ATR_Mult_Factor1_on,ATR_applied_price_on,ATR_fontsize_on,1,1);   
      ATR_op_0 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_on,ATR_MA_Periods_on,ATR_MA_type_on,ATR_Mult_Factor1_on,ATR_applied_price_on,ATR_fontsize_on,0,1);   
      bars_ATR_tf = iTime(NULL,ATR_tf, 1);
   }   
   if (ATR_Channels_cl_on && iTime (NULL, ATR_tf,1) > bars_ATR_tf_cl)
   {
      ATR_cl_1 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_cl,ATR_MA_Periods_cl,ATR_MA_type_cl,ATR_Mult_Factor1_cl,ATR_applied_price_cl,ATR_fontsize_cl,1,1);   
      ATR_cl_0 = iCustom(NULL,ATR_tf,"ATR Channels_EA",ATR_PeriodsATR_cl,ATR_MA_Periods_cl,ATR_MA_type_cl,ATR_Mult_Factor1_cl,ATR_applied_price_cl,ATR_fontsize_cl,0,1);   
      bars_ATR_tf_cl = iTime(NULL,ATR_tf, 1);
   }
   //+----------------------------- ëèíèÿ òðåéëèíã-ñòîï----------------------------+

   if(GridTSon > 0)                 //òðåéëèíã-ñòîï ðàçðåøåí?
   {
      if(countsell >= 1) 
      {        
         Gridprice(OP_SELL);
         if(GridTS<=0)   // èìåþòñÿ îòêðûòûå SELL îðäåðà è íåò ëèíèè TS?
         {
            CheckCloseTrades (true);
            if (  (Ask <= (avgpriceSELL-TS_ATR))  
               && (  CP_sell)
               && (     GridTSon == 2
                  || (  GridTSon == 1
                     && (  qdc <= 0
                        || (!reverse && Quantum_cl_sell>0) 
                        || ( reverse && Quantum_cl_buy>0) 
                        )
                     && (  !iMA_cl_on
                        || Bid > iMA_cl
                        )
                     && (  !Stochastic_cl_on 
                        || (Stochastic_cl<Stochastic_OS_cl) 
                        )
                     && (  !Pfe_cl_on
                        || (Pfe_cl < - Pfe_Level_cl)
                        )
                     && (  !MACD_Xtr_cl_on 
                        || (!reverse && MACD_Xtr_4_cl<0) 
                        || ( reverse && MACD_Xtr_3_cl>0)
                        )
                     && (  !ChannelsFIBO_MTF_AD_EA_cl_on  
                        || (!reverse && !i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_1) 
                        || (!reverse &&  i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_1)
                        || ( reverse && !i_open_cl && High[1] > ChannelsFIBO_MTF_cl_0)
                        || ( reverse &&  i_open_cl && High[1] > ChannelsFIBO_MTF_cl_1)
                        )
                     && (  !ChannelsFIBO_v2_MTF_AD_EA_cl_on    
                        || (!reverse && !i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_1)
                        || (!reverse &&  i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_0)
                        || ( reverse && !i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_0)
                        || ( reverse &&  i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_1)
                        ) 
                     &&(   !Envelopes_cl_on  
                        || (!reverse && !env_open_cl && Low [1] < Envelopes_cl_LO)
                        || (!reverse &&  env_open_cl && Low [1] < Envelopes_cl_UP)
                        || ( reverse && !env_open_cl && High[1] > Envelopes_cl_UP)
                        || ( reverse &&  env_open_cl && High[1] > Envelopes_cl_LO)
                        )
                     && (  !ATR_Channels_cl_on  
                        || (!reverse && !ATR_Channels_op_cl && Low[1]  < ATR_cl_1) 
                        || (!reverse &&  ATR_Channels_op_cl && Low[1]  < ATR_cl_0)
                        || ( reverse && !ATR_Channels_op_cl && High[1] > ATR_cl_0)
                        || ( reverse &&  ATR_Channels_op_cl && High[1] > ATR_cl_1)
                        )
                     && (  !MA_Kiosotto_cl_on
                        || (!reverse && MA_Kiosotto_cl_sell>MA_Kiosotto_MA_cl)
                        || (  reverse && MA_Kiosotto_cl_buy>MA_Kiosotto_MA_cl)
                        )
                     )      
                  )
               )   
            {
               GridTS = NormalizeDouble(Ask+TSstep_ATR,Digits);
               TS_Name = "TS-" + TimeToStr(TimeCurrent());
               ObjectCreate(0,TS_Name,OBJ_ARROW,0,0,0,0,0);          // ñîçäàäèì ñòðåëêó 
               ObjectSetInteger(0,TS_Name,OBJPROP_ARROWCODE,224);    // óñòàíîâèì êîä ñòðåëêè 
               ObjectSetInteger(0,TS_Name,OBJPROP_TIME,TimeCurrent());        // çàäàäèì âðåìÿ 
               ObjectSetDouble(0,TS_Name,OBJPROP_PRICE,GridTS);// çàäàäèì öåíó 
               ChartRedraw(0);                                        // ïåðåðèñóåì îêíî 
            }      
         }
         else
         { 
            if(Ask <= (GridTS - TSstep_ATR)) 
               GridTS = NormalizeDouble (Ask + TSstep_ATR, Digits);       //ðàñ÷èòûâàåì íîâóþ öåíó TrailingStop ñåòêè           /                       /     /
         }
         ObjectSet("TrailingStop", OBJPROP_PRICE1, GridTS); //îòîáðàæåíèå ðàçðåøåíî? - ðèñóåì ëèíèþ TrailingStop ñåòêè
      }
      if(countbuy >= 1)         // èìåþòñÿ îòêðûòûå BUY îðäåðà?
      {
         Gridprice(OP_BUY);
         if(GridTS<=0)      // åñëè ëèíèÿ TS BUY åùå íå ðàñ÷èòàíà
         {
            CheckCloseTrades (true);            
            if (  (Bid >= (avgpriceBUY + TS_ATR))  
               && (  CP_buy)
               && (     GridTSon == 2
                  || (  GridTSon == 1
                     && (   qdc <= 0
                        || (!reverse && Quantum_cl_buy>0) 
                        || ( reverse && Quantum_cl_sell>0) 
                        )
                     && (  !iMA_cl_on
                        ||  Ask < iMA_cl
                        )
                     && (  !Stochastic_cl_on 
                        || (Stochastic_cl>Stochastic_OB_cl) 
                        )
                     && (  !Pfe_cl_on
                        || (Pfe_cl > Pfe_Level_cl)
                        )
                     && (  !MACD_Xtr_cl_on 
                        || (!reverse && MACD_Xtr_3_cl>0) 
                        || ( reverse && MACD_Xtr_4_cl<0)
                        )
                     && (  !ChannelsFIBO_MTF_AD_EA_cl_on  
                        || ( reverse && !i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_1) 
                        || ( reverse &&  i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_0) 
                        || (!reverse && !i_open_cl && High[1] > ChannelsFIBO_MTF_cl_0)
                        || (!reverse &&  i_open_cl && High[1] > ChannelsFIBO_MTF_cl_1)
                        )
                     && (  !ChannelsFIBO_v2_MTF_AD_EA_cl_on    
                        || ( reverse && !i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_1)
                        || ( reverse &&  i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_0)
                        || (!reverse && !i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_0)
                        || (!reverse &&  i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_1)
                        ) 
                     && (  !Envelopes_cl_on  
                        || ( reverse && !env_open_cl && Low [1] < Envelopes_cl_LO)
                        || ( reverse &&  env_open_cl && Low [1] < Envelopes_cl_UP)
                        || (!reverse && !env_open_cl && High[1] > Envelopes_cl_UP)
                        || (!reverse &&  env_open_cl && High[1] > Envelopes_cl_LO)
                        )
                     && (   !ATR_Channels_cl_on  
                        || ( reverse && !ATR_Channels_op_cl && Low[1]  < ATR_cl_1) 
                        || ( reverse &&  ATR_Channels_op_cl && Low[1]  < ATR_cl_0)
                        || (!reverse && !ATR_Channels_op_cl && High[1] > ATR_cl_0)
                        || (!reverse &&  ATR_Channels_op_cl && High[1] > ATR_cl_1)
                        )
                     && (  !MA_Kiosotto_cl_on
                        || (!reverse && MA_Kiosotto_cl_buy>MA_Kiosotto_MA_cl)
                        || ( reverse && MA_Kiosotto_cl_sell>MA_Kiosotto_MA_cl)
                        )
                     )
                  )            
               )
            {   
               GridTS = NormalizeDouble(Bid - TSstep_ATR, Digits);       //ðàñ÷èòûâàåì íîâóþ öåíó TrailingStop ñåòêè           /                       /     /
               TS_Name = "TS-" + TimeToStr(TimeCurrent());
               ObjectCreate(0,TS_Name,OBJ_ARROW,0,0,0,0,0);          // ñîçäàäèì ñòðåëêó 
               ObjectSetInteger(0,TS_Name,OBJPROP_ARROWCODE,224);    // óñòàíîâèì êîä ñòðåëêè 
               ObjectSetInteger(0,TS_Name,OBJPROP_TIME,TimeCurrent());        // çàäàäèì âðåìÿ 
               ObjectSetDouble(0,TS_Name,OBJPROP_PRICE,GridTS);// çàäàäèì öåíó 
               ChartRedraw(0);                                        // ïåðåðèñóåì îêíî 
            }
         }
         else 
         {
            if(Bid >= (GridTS + TSstep_ATR)) GridTS = NormalizeDouble (Bid - TSstep_ATR, Digits);       //ðàñ÷èòûâàåì íîâóþ öåíó TrailingStop ñåòêè           /                       /     /
         }
         ObjectSet("TrailingStop", OBJPROP_PRICE1, GridTS);        //îòîáðàæåíèå ðàçðåøåíî? - ðèñóåì ëèíèþ TrailingStop ñåòêè
      }
   }
//+---------------------------------------------------------------------------------+

   if(   (openorders)>0 
//      && (  !Virt_Order_on
//         ||( Virt_Order_on && !Virt_TS_on)
//         )
     )
      CheckCloseTrades(false);
//+----------------------------------- òåñòîâûé ðåæèì ---------------------------------
   if (IsTesting()) 
   {
      if(MAX_EQUITY_DD < Test_Free_Margin - AccountFreeMargin())
         MAX_EQUITY_DD = Test_Free_Margin - AccountFreeMargin();
      if((AccFreeMargin > 0.0) && (AccountFreeMargin() < Test_Free_Margin) && (MAX_EQUITY_DD > AccFreeMargin)) 
      {
         Alert("Ñòîï, ñòàðòîâàÿ ìàðæà= ", NormalizeDouble(Test_Free_Margin,2), " îñòàòîê ", 
            NormalizeDouble(AccountFreeMargin(),2), " ïðåâûøåí íà÷àëüíûé äåïîçèò ÅÀ íà ",               
            NormalizeDouble(Test_Free_Margin -AccountFreeMargin()- AccFreeMargin, 2),
            " ïðè AccFreeMargin=", AccFreeMargin);
         ExpertRemove(); int b = 0; int stop_ea = 1/b; // Äåëåíèå íà 0 äëÿ íåøòàòíîãî çàâåðøåíèÿ òåñòèðîâàíèÿ 
      }      
   }
//+------------------------------------------------------------------------------------

   if(optionLot==3)
   {
      if(grid1size==0 || grid2size==0 || grid3size==0 || grid4size==0)
      {
         Alert("Please set ALL grid sizes");
         return(0);
      }
      g1s=grid1size*Point*digits;
      g2s=grid2size*Point*digits;
      g3s=grid3size*Point*digits;
      g4s=grid4size*Point*digits;
   }
//Open trades after Trading Window Start Time and before Trading Window End Time
   Prevorderprice();   
   bool buttonstarted=ObjectGetInteger(0,"start",OBJPROP_STATE);
//check cycles per trading slot 
   bool gocycle=true;
   if(!fulltime)
   {
      if((cyc_var==1) || (cyc_var==0 && openorders==0))
      {   
         if (  (curtime>=open1 && curtime<close1 && cyc1>0 && c1>=cyc1) 
            || (curtime>=open2 && curtime<close2 && cyc2>0 && c2>=cyc2) 
            || (curtime>=open3 && curtime<close3 && cyc3>0 && c3>=cyc3) 
            )
            gocycle=false;
      }
   }
   if ((stop && buttonstarted && openorders<=0) || !stop || openorders>0)
   {
      if ((cyc_var==1 && cycles < numcycles && numcycles>0) || (cyc_var==0 && cycles<=numcycles && numcycles>0 && openorders >0) || numcycles<=0)
      {
         if (gocycle)
         {
            if (barNext  
               && (  fulltime 
                  || ((curtime>=open1 && curtime<close1) && (trad1 <=0 || (trad1 >0 && openorders < trad1)))
                  || ((curtime<open1 || curtime>close1) && close1 > open1 && contgrid && openorders>0 && (trad1 <=0 || (trad1 >0 && openorders < trad1)))
                  || ((curtime>=open2 && curtime<close2) && (trad2 <=0 || (trad2 >0 && openorders < trad2)))
                  || (curtime>close2 && close2 > open2 && contgrid && openorders>0 && (trad2 <=0 || (trad2 >0 && openorders < trad2)))
                  || ((curtime>=open3 && curtime<close3) && (trad3 <=0 || (trad3 >0 && openorders < trad3)))
                  || (curtime>close3 && close3 > open3 && contgrid && openorders>0 && (trad3 <=0 || (trad3 >0 && openorders < trad3)))
                  ) 
               )
            {
               bool cantrade=true;
               if(   (  (!reverse && Quantum_op_buy>0) 
                     || (reverse && Quantum_op_sell>0) 
                     )
                     && (countsell <=0 || Virt_Order_on)
                 )
               {
                  //===== ïîäêëþ÷åíèå ôèëüòðîâ ============                  
                  
                  if (  (  !GX_on
                        || countbuy > 0
                        || (countbuy == 0 && Low[1] < GX_price_buy)
                        )
                     && (  !Stochastic_op_on 
                        || Stochastic_op<Stochastic_OS_op 
                        )
                     && (  !Pfe_op_on
                        || (Pfe_op < - Pfe_Level_op)
                        )
                     && (  !iMA_op_on
                        ||  Bid > iMA_op
                        )   
                     && (  !MA_4H_op_on
                        || (Ask > MA_4H_level_0 && Ask <= (MA_4H_level_0 + MA_4H_ATR_level_1)) 
                        || (Ask <= (MA_4H_level_0 - MA_4H_ATR_level_2))
                        )
                     && (  !MACD_Xtr_on 
                        || ( reverse && MACD_Xtr_3>0)
                        || (!reverse && MACD_Xtr_4<0)
                        )
                     && (  !ChannelsFIBO_MTF_AD_EA_on  
                        || ( reverse && High[1] > ChannelsFIBO_MTF_op_0) 
                        || (!reverse && Low[1]  < ChannelsFIBO_MTF_op_1)
                        )
                     && (  !ChannelsFIBO_v2_MTF_AD_EA_on  
                        || ( reverse && High[1] > ChannelsFIBO_v2_op_0) 
                        || (!reverse && Low[1]  < ChannelsFIBO_v2_op_1)
                        )
                     && (  !Envelopes_on  
                        || ( reverse && High[1] > Envelopes_op_UP)
                        || (!reverse && Low [1] < Envelopes_op_LO)
                        )
                     && (   !ATR_Channels_op_on  
                        || (!reverse && Low[1]  < ATR_op_1) 
                        || ( reverse && High[1] > ATR_op_0)
                        )
                     && (  !MA_Kiosotto_op_on 
                        || (!reverse && MA_Kiosotto_op_buy >MA_Kiosotto_MA_op)
                        || ( reverse && MA_Kiosotto_op_sell>MA_Kiosotto_MA_op)
                        )   
                     )
                  {
                     sellclosed=false;
                     if(wait>0 && thewaitbuy<=wait)
                     {
                        thewaitsell=0;
                        thewaitbuy+=1;
                     }
                     if(wait<=0 || (wait>0 && thewaitbuy>wait))
                     {
                        cantrade=true;
                        countbuy=CountTrades(OP_BUY);
                        if(optionLot==3)
                        { 
                           if(OrdersTotal()>0)
                           {
                              grid1trades=0; grid2trades=0; grid3trades=0; grid4trades=0;
                              for(int j=OrdersTotal()-1;j>=0;j--)
                              {
                                 if(!OrderSelect(j,SELECT_BY_POS,MODE_TRADES))          continue;
                                 if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                                 {
                                    double Order_Open_Price = OrderOpenPrice();
                                    if(Order_Open_Price>initialstartbuy-g1s)                                                              grid1trades+=1;
                                    if(Order_Open_Price<=initialstartbuy-g1s && Order_Open_Price>initialstartbuy-g1s-g2s)                 grid2trades+=1;
                                    if(Order_Open_Price<=initialstartbuy-g1s-g2s && Order_Open_Price>initialstartbuy-g1s-g2s-g3s)         grid3trades+=1;
                                    if(Order_Open_Price<=initialstartbuy-g1s-g2s-g3s && Order_Open_Price>initialstartbuy-g1s-g2s-g3s-g4s) grid4trades+=1;
                                 }
                              }
                           }
                           if (  (Ask>initialstartbuy-g1s && ((grid1trades>=grid1maxtrades && grid1maxtrades>0) || (prevorderprice>0 && prevorderprice-(grid1inc*Point*digits)<=Ask)))
                              || (Ask<=initialstartbuy-g1s && Ask>initialstartbuy-g1s-g2s && ((grid2trades>=grid2maxtrades && grid2maxtrades>0) || (prevorderprice-(grid2inc*Point*digits)<=Ask)))
                              || (Ask<=initialstartbuy-g1s-g2s && Ask>initialstartbuy-g1s-g2s-g3s && ((grid3trades>=grid3maxtrades && grid3maxtrades>0) || (prevorderprice-(grid3inc*Point*digits)<=Ask)))
                              || (Ask<=initialstartbuy-g1s-g2s-g3s && Ask>initialstartbuy-g1s-g2s-g3s-g4s && ((grid4trades>=grid4maxtrades && grid4maxtrades>0) || (prevorderprice-(grid4inc*Point*digits)<=Ask)))
                              )
                              cantrade=false;
                        }      
                        if (cantrade
                           && (  (!mon     && DayOfWeek()==1)
                              || (!tue     && DayOfWeek()==2)
                              || (!wed     && DayOfWeek()==3)
                              || (!thurs   && DayOfWeek()==4)
                              || (!fri     && DayOfWeek()==5)
                              || (prevorderprice-(xdist*MathPow(multi_xdist,countbuy * exponent_factor_xdist)*Point)<=Ask && xdist>0 && prevorderprice>0)      
                              || (had && iCustom(Symbol(),PERIOD_W1,"Heiken Ashi",Red,White,Red,White,2,0)>iCustom(Symbol(),0,"Heiken Ashi",Red,White,Red,White,3,0))   
                              || (xcandles>0 && lastorderbar>0 && lastorderbar<xcandles)
                              || (Ask>prevorderprice && prevorderprice!=0 && onlylowerhigher)
                              || (MarketInfo(Symbol(),MODE_SPREAD)>Spred )
                              )  
                           )      
                           cantrade=false;
                        if(cantrade)
                        {
                           if(stop==true)
                              ObjectSetInteger(0,"start",OBJPROP_STATE,false);
                           if(Virt_Order_on && Virt_Order_buy==0)// && Virt_Order_sell==0)
                           {
//                              Virt_Order_dist=percATR(Virt_Order_dist_perc,Virt_Order_TF,Virt_Order_Period);      
                              Virt_Order_buy=Ask+Virt_Order_dist;
                              ObjectSet("Virt_Order_BUY",OBJPROP_PRICE1,Virt_Order_buy);
                           }
                           if(!Virt_Order_on)// || (Virt_Order_on && countbuy >0))
                           {
                              lots=GetLots(Ask,"Buy");
                              if(lots>0)
                                 OpenOrder(OP_BUY);

                              if(countbuy==1)
                              {
                                 initialstartbuy=Ask;
                                 initialstartsell=0;
                                 if(drawgrid)
                                 {
                                    Alert("Grid should have been drawn");
                                    DrawGrid(initialstartbuy,"Buy");
                                 }
                              }
                           }
                        }
                     }
                  }
               }
               if(   (  (!reverse && Quantum_op_sell>0) 
                     || ( reverse && Quantum_op_buy>0) 
                     )
                  && (countbuy<=0 || Virt_Order_on)
                 )
               {
                  if (  (  !GX_on
                        || countsell > 0
                        || (countsell == 0 && High[1] > GX_price_sell)
                        )
                     && (  !Stochastic_op_on 
                        || Stochastic_op>Stochastic_OB_op 
                        )
                     && (  !Pfe_op_on
                        || Pfe_op > Pfe_Level_op
                        )
                     && (  !iMA_op_on
                        || Ask < iMA_op
                        )   
                     && (  !MA_4H_op_on
                        || (Bid < MA_4H_level_0 && Bid >= (MA_4H_level_0 - MA_4H_ATR_level_1)) 
                        || (Bid >= (MA_4H_level_0 + MA_4H_ATR_level_2))
                        )
                     && (  !MACD_Xtr_on 
                        || (!reverse && MACD_Xtr_3>0)
                        || ( reverse && MACD_Xtr_4<0)
                        )
                     && (  !ChannelsFIBO_MTF_AD_EA_on  
                        || (!reverse && High[1] > ChannelsFIBO_MTF_op_0) 
                        || ( reverse && Low[1]  < ChannelsFIBO_MTF_op_1)
                        )
                     && (  !ChannelsFIBO_v2_MTF_AD_EA_on  
                        || (!reverse && High[1] > ChannelsFIBO_v2_op_0) 
                        || ( reverse && Low[1]  < ChannelsFIBO_v2_op_1)
                        )
                     && (  !Envelopes_on  
                        || (!reverse && High[1] > Envelopes_op_UP)
                        || ( reverse && Low [1] < Envelopes_op_LO)
                        )
                     && (   !ATR_Channels_op_on  
                        || ( reverse && Low[1]  < ATR_op_1) 
                        || (!reverse && High[1] > ATR_op_0)
                        )
                     && (  !MA_Kiosotto_op_on 
                        || (!reverse && MA_Kiosotto_op_sell>MA_Kiosotto_MA_op)
                        || ( reverse && MA_Kiosotto_op_buy >MA_Kiosotto_MA_op)
                        )   
                     )
                  {
                     buyclosed=false;
                     if(wait>0 && thewaitsell<=wait)
                     {
                        thewaitbuy=0;
                        thewaitsell+=1;
                     }
                     if(wait<=0 || (wait>0 && thewaitsell>wait))
                     {
                        cantrade=true;
                        countsell=CountTrades(OP_SELL);
                        if(optionLot==3) 
                        {   
                           if (OrdersTotal()>0)
                           {
                              grid1trades=0;
                              grid2trades=0;
                              grid3trades=0;
                              grid4trades=0;
                              for(int j=OrdersTotal()-1;j>=0;j--)
                              {
                                 if(!OrderSelect(j,SELECT_BY_POS,MODE_TRADES))   continue;
                                 if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                                 {
                                    double Order_Open_Price = OrderOpenPrice();
                                    if(Order_Open_Price<initialstartsell+g1s)                                                                grid1trades+=1;
                                    if(Order_Open_Price>=initialstartsell+g1s && Order_Open_Price<initialstartsell+g1s+g2s)                  grid2trades+=1;
                                    if(Order_Open_Price>=initialstartsell+g1s+g2s && Order_Open_Price<initialstartsell+g1s+g2s+g3s)          grid3trades+=1;
                                    if(Order_Open_Price>=initialstartsell+g1s+g2s+g3s && Order_Open_Price<initialstartsell+g1s+g2s+g3s+g4s)  grid4trades+=1;
                                 }
                              }
                           }
                        if (  (Bid<initialstartsell+g1s && ((grid1trades>=grid1maxtrades && grid1maxtrades>0) || (prevorderprice>0 && prevorderprice+(grid1inc*Point*digits)>=Bid)))
                           || (Bid>=initialstartsell+g1s && Bid<initialstartsell+g1s+g2s && ((grid2trades>=grid2maxtrades && grid2maxtrades>0) || (prevorderprice+(grid2inc*Point*digits)>=Bid)))
                           || (Bid>=initialstartsell+g1s+g2s && Bid<initialstartsell+g1s+g2s+g3s && ((grid3trades>=grid3maxtrades && grid3maxtrades>0) || (prevorderprice+(grid3inc*Point*digits)>=Bid)))
                           || (Bid>=initialstartsell+g1s+g2s+g3s && Bid<initialstartsell+g1s+g2s+g3s+g4s && ((grid4trades>=grid4maxtrades && grid4maxtrades>0) || (prevorderprice+(grid4inc*Point*digits)>=Bid)))
                           )
                           cantrade=false;
                        }
                        if (cantrade
                           && (  (!mon    && DayOfWeek()==1)
                              || (!tue    && DayOfWeek()==2)
                              || (!wed    && DayOfWeek()==3)
                              || (!thurs  && DayOfWeek()==4)
                              || (!fri    && DayOfWeek()==5)
                              || (prevorderprice+(xdist*MathPow(multi_xdist,countsell * exponent_factor_xdist)*Point)>=Bid && xdist>0 && prevorderprice>0)
                              || (had && iCustom(Symbol(),PERIOD_W1,"Heiken Ashi",Red,White,Red,White,2,0)<iCustom(Symbol(),0,"Heiken Ashi",Red,White,Red,White,3,0))
                              || (xcandles>0 && lastorderbar>0 && lastorderbar<xcandles)
                              || (Bid<prevorderprice && onlylowerhigher)
                              || (MarketInfo(Symbol(),MODE_SPREAD)>Spred)
                              )
                           )
                           cantrade=false;
                        if(cantrade)
                        {
                           if(stop==true)
                              ObjectSetInteger(0,"start",OBJPROP_STATE,false);
                           if(Virt_Order_on && Virt_Order_sell==0)// && Virt_Order_buy==0)
                           {               
//                              Virt_Order_dist=percATR(Virt_Order_dist_perc,Virt_Order_TF,Virt_Order_Period);      
                              Virt_Order_sell=Bid-Virt_Order_dist;
                              ObjectSet("Virt_Order_SELL",OBJPROP_PRICE1,Virt_Order_sell);
                           }
                           if(!Virt_Order_on)// || (Virt_Order_on && countsell >0))
                           {
                              lots=GetLots(Bid,"Sell");
                              if(lots>0)
                                 OpenOrder(OP_SELL);
                              if(countsell == 1)
                              {
                                 initialstartsell=Bid;
                                 initialstartbuy=0;
                                 if(drawgrid==true)
                                 {
                                 Alert("Grid should have been drawn");
                                 DrawGrid(initialstartsell,"Sell");
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }
   if(qde_oc==1)barNext = false;
   prevtime=iTime(Symbol(),tf,0);
   return(0);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double GetLots(double price,string dir)
{
   double runningprofit =0;
   if ((MaxPercDepo <1) && (AccountEquity() < AccountBalance() * (1-MaxPercDepo)))   
      return(-1);
   if ((MaxPercFree < 1) && openorders != 0)
   {
      for(int a=OrdersTotal()-1;a>=0;a--)
      {
         if(!OrderSelect(a,SELECT_BY_POS,MODE_TRADES))
            continue;
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
            runningprofit+=OrderProfit()+OrderCommission()+OrderSwap();
      }
      if (runningprofit < -MaxPercFree * AccountFreeMargin())
               return(-2);
   }
   if (IsTesting() && (AccFreeMargin > 0.0) && (openorders == 0)) Test_Free_Margin = AccountFreeMargin();
   if (optionLot == 0)
      retlots = LotRound(FixLot*MathPow(multip1,openorders*multip2));
      
   if (optionLot == 1)
   {
      if (FirstLot == 0)
      {
         if (openorders == 0)
         {
            if (IsTesting() && (AccFreeMargin > 0.0))// åñëè òåñòèðóåì è ìàðæà ôèêñèðîâàíà AccFreeMargin
               FirstLot = PercentOfDepo*MathMin(AccountFreeMargin(),AccFreeMargin) / MarketInfo(Symbol(), MODE_MARGINREQUIRED);
            else // åñëè íå òåñòèðóåì, òî ïåðâûé ëîò ñ÷èòàåì îò ñâîáîäíîé ìàðæè
               FirstLot = PercentOfDepo*AccountFreeMargin() / MarketInfo(Symbol(), MODE_MARGINREQUIRED);
         } 
         else
         {
            for(int a=OrdersTotal()-1;a>=0;a--)
            {
               if(!OrderSelect(a,SELECT_BY_POS,MODE_TRADES))
                  continue;
               if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                  FirstLot = OrderLots();
            }
         }
      }            
      retlots = LotRound(FirstLot*MathPow(multip1, openorders*multip2));
      if (IsTesting() && (AccFreeMargin > 0.0)) Alert("Retlots=",retlots," FirstLot=",FirstLot, " PercentOfDepo=",PercentOfDepo,
            " FreeMargin=",NormalizeDouble(AccountFreeMargin(), 2) , " MARGINREQ=",MarketInfo(Symbol(), MODE_MARGINREQUIRED));      
   }
   if(optionLot == 2)
   {
      if(openorders  >=0   && openorders<12) retlots=LotRound(T1);
      if(openorders  >=12  && openorders<21) retlots=LotRound(T2);
      if(openorders  >=21  && openorders<29) retlots=LotRound(T3);
      if(openorders  >=29  && openorders<36) retlots=LotRound(T4);
      if(openorders  >=36  && openorders<39) retlots=LotRound(T5);
      if(openorders  >=39)                   retlots=LotRound(T6);
   }

   if(optionLot == 3)
   {
      g1s=grid1size*Point*digits;
      g2s=grid2size*Point*digits;
      g3s=grid3size*Point*digits;
      g4s=grid3size*Point*digits;
      if(openorders<=0)
         retlots=LotRound(grid1lots);
      if(openorders>0)
      {
         if(dir=="Buy")
         {
            if(price >  initialstartbuy-g1s)                                                    retlots=LotRound(grid1lots);
            if(price >= initialstartbuy-g1s-g2s && price<initialstartbuy-g1s)                   retlots=LotRound(grid2lots);
            if(price >= initialstartbuy-g1s-g2s-g3s && price<initialstartbuy-g1s-g2s)           retlots=LotRound(grid3lots);
            if(price >= initialstartbuy-g1s-g2s-g3s-g4s && price<initialstartbuy-g1s-g2s-g3s)   retlots=LotRound(grid4lots);
            if(price <  initialstartbuy-g1s-g2s-g3s-g4s)                                        retlots=LotRound(grid4lots);
         }
         if(dir=="Sell")
         {
            if(price <  initialstartsell+g1s)                                                   retlots=LotRound(grid1lots);
            if(price <= initialstartsell+g1s+g2s && price>initialstartsell+g1s)                 retlots=LotRound(grid2lots);
            if(price <= initialstartsell+g1s+g2s+g3s && price>initialstartsell+g1s+g2s)         retlots=LotRound(grid3lots);
            if(price <= initialstartsell+g1s+g2s+g3s+g4s && price>initialstartsell+g1s+g2s+g3s) retlots=LotRound(grid4lots);
            if(price >= initialstartsell+g1s+g2s+g3s+g4s)                                       retlots=LotRound(grid4lots);
         }
      }
   }
   return(retlots);
}
//+-------------------------------------------------------------------------------------+
//| Ïðîâåðêà îáúåìà íà êîððåêòíîñòü è îêðóãëåíèå                                        |
//+-------------------------------------------------------------------------------------+
double LotRound(double L)
{
   return(MathRound(MathMin(MathMax(L, MarketInfo(Symbol(),MODE_MINLOT)), MarketInfo(Symbol(),MODE_MAXLOT))/MarketInfo(Symbol(),MODE_LOTSTEP))*MarketInfo(Symbol(),MODE_LOTSTEP));
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CheckCloseTrades(bool TS_CCT)
{
   int runningpoints=0;
   double runningprofit=0;
   double order_lots=0;   
   bool CloseTrades=false;
   bool CloseManual=false;
   bool closeonsell=false;
   bool closeonbuy=false;

   for(int a=OrdersTotal()-1;a>=0;a--)
   {
      if(!OrderSelect(a,SELECT_BY_POS,MODE_TRADES))
         continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
      {
         order_lots += OrderLots();                            //                                              /
         runningprofit+=OrderProfit()+OrderCommission()+OrderSwap();
         if(OrderType()==OP_BUY)
            closeonsell=true;
         if(OrderType()==OP_SELL)
            closeonbuy=true;
      }
   }
   runningpoints = int(runningprofit / (order_lots * Point * MathPow(10, Digits)));

   if(manual)
   {
      CloseManual=ObjectGetInteger(0,"manual",OBJPROP_STATE);
      ObjectSetInteger(0,"manual",OBJPROP_STATE,0);
   }
   else
   {
      if (  (runningprofit<=dollarsl && dollarsl<0) 
         || (AccountEquity()<=(AccountBalance()+((AccountBalance()*percequitysl)/100)) && percequitysl<0) 
         || (runningpoints<=pointssl && pointssl<0) 
         )
      {
         if (stop_sl)
            stop = true;
         CloseTrades=true;
      }
      if (
            (runningprofit>=dollartp && dollartp>0)
         || (AccountEquity()>=(AccountBalance()+((AccountBalance()*percequitytp)/100)) && percequitytp>0)
         || (runningpoints>=pointstp && pointstp>0)
         || ((!fulltime && closeend)
            && (  ((curtime > close1) && ((curtime < open2) || (open2 - close1 < 0)) && (close1-open1)>0)
               || ((curtime > close2) && ((curtime < open3) || (open3 - close2 < 0)) && (close2-open2)>0)
               || ((curtime > close3) && (close3 - open3) > 0)
               )
            )
         )
         CloseTrades=true;
   }

   if (closeonsell)
   {
      if (  (CloseProfit_min <= 0) 
         || (GridTSon > 0 && GridTS >0 && CP_TS)
         || (countbuy < CloseProfit_min)
         || (CloseProfit_max > 0 && countbuy > CloseProfit_max)
         || (  (  (CloseProfit_max <= 0   && countbuy >= CloseProfit_min)
               || (CloseProfit_max >  0   && countbuy >= CloseProfit_min && countbuy <= CloseProfit_max)
               )
            && (  (CloseProfit         >  0 && runningprofit >= CloseProfit) 
               || (CloseProfit_Points  >  0 && runningpoints >= CloseProfit_Points)
               || (CP_ATR              >  0 && runningpoints >= CP_ATR)
               )
            )
         ) 
         CP_buy = true;
      else
      {
         CP_buy = false;   
         if (GridTSon > 0 && GridTS >0 && Bid <= GridTS && !CP_TS)
            GridTS =0;
      }
   }
   if (closeonbuy)
   {
      if (  (  CloseProfit_min <= 0) 
         ||   (GridTSon > 0 && GridTS >0 && CP_TS)
         || (countsell < CloseProfit_min)
         || (CloseProfit_max > 0 && countsell > CloseProfit_max)
         || (  (  (CloseProfit_max <= 0 && countsell >= CloseProfit_min)
               || (CloseProfit_max > 0 && countsell >= CloseProfit_min && countsell <= CloseProfit_max)
               )
            && (  (CloseProfit         >  0 && runningprofit >= CloseProfit) 
               || (CloseProfit_Points  >  0 && runningpoints >= CloseProfit_Points)
               || (CP_ATR              >  0 && runningpoints >= CP_ATR)
               )
            )
         )
         CP_sell = true;   
      else
      {
         CP_sell = false;
         if (GridTSon > 0 && GridTS >0 && Ask >= GridTS && !CP_TS)
            GridTS =0;
      }
   }    
   if (  TS_CCT
      || (  Spred_on > 1 && MarketInfo(Symbol(),MODE_SPREAD)>Spred )
      )
      return;     
   if (  closeonsell 
      && ( ( manual && CloseManual)
         || (!manual
            && (   CloseTrades
               || (GridTSon > 0 && GridTS >0 && Bid <= GridTS)
               || (  (  !NC_on
                     || (NC_1 > NC_2 && (curtime >= NC_2 && curtime < NC_1))  
                     || (NC_1 < NC_2 && (curtime >= NC_2 || curtime < NC_1))
                     )
                  && (CP_buy) 
                  && (   GridTSon == 0 
                     || (GridTSon > 0 && GridTS <=0)
                     )
                  && (qdc >0 || MACD_Xtr_cl_on || ChannelsFIBO_MTF_AD_EA_cl_on || ChannelsFIBO_v2_MTF_AD_EA_cl_on || Envelopes_cl_on || Stochastic_cl_on || Pfe_cl_on || MA_Kiosotto_cl_on || iMA_cl_on || ATR_Channels_cl_on)
                  && (  qdc<=0  
                     || (!reverse && Quantum_cl_buy>0) 
                     || ( reverse && Quantum_cl_sell>0) 
                     )   
                  && (  !Stochastic_cl_on 
                     || (Stochastic_cl>Stochastic_OB_cl) 
                     )
                  && (  !Pfe_cl_on
                     || (Pfe_cl > Pfe_Level_cl)
                     )   
                  && (  !iMA_cl_on
                     || (Ask < iMA_cl)
                     )   
                  && (  !MACD_Xtr_cl_on 
                     || (!reverse && MACD_Xtr_3_cl>0) 
                     || ( reverse && MACD_Xtr_4_cl<0)
                     )
                  && (  !ChannelsFIBO_MTF_AD_EA_cl_on  
                     || (!reverse && !i_open_cl && High[1] > ChannelsFIBO_MTF_cl_0) 
                     || (!reverse &&  i_open_cl && High[1] > ChannelsFIBO_MTF_cl_1) 
                     || ( reverse && !i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_1)
                     || ( reverse &&  i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_0)
                     )
                  && (  !ChannelsFIBO_v2_MTF_AD_EA_cl_on    
                     || (!reverse && !i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_0) 
                     || (!reverse &&  i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_1) 
                     || ( reverse && !i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_1)
                     || ( reverse &&  i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_0)
                    )    
                  && (  !Envelopes_cl_on  
                     || (!reverse && !env_open_cl && High[1] > Envelopes_cl_UP)
                     || (!reverse &&  env_open_cl && High[1] > Envelopes_cl_LO)
                     || ( reverse && !env_open_cl && Low [1] < Envelopes_cl_LO)
                     || ( reverse &&  env_open_cl && Low [1] < Envelopes_cl_UP)
                    )
                  && (   !ATR_Channels_cl_on  
                     || (!reverse && !ATR_Channels_op_cl && High[1] > ATR_cl_0) 
                     || (!reverse &&  ATR_Channels_op_cl && High[1] > ATR_cl_1)
                     || ( reverse && !ATR_Channels_op_cl && Low [1] < ATR_cl_1)
                     || ( reverse &&  ATR_Channels_op_cl && Low [1] < ATR_cl_0)
                    )
                  && (  !MA_Kiosotto_cl_on 
                     || (!reverse && MA_Kiosotto_cl_buy >MA_Kiosotto_MA_cl)
                     || ( reverse && MA_Kiosotto_cl_sell>MA_Kiosotto_MA_cl)
                     )      
                  )
               )
            )
         )   
      )
      CloseNormal();
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   if(closeonbuy 
      && (  ( manual && CloseManual)
         || (!manual
            && (  CloseTrades
               || (GridTSon > 0 && GridTS >0 && Ask >= GridTS)
               || (  ( !NC_on
                     || (NC_1 > NC_2 && (curtime >= NC_2 && curtime < NC_1))  
                     || (NC_1 < NC_2 && (curtime >= NC_2 || curtime < NC_1))
                     )
                  && (CP_sell)
                  && (   GridTSon == 0 
                     || (GridTSon > 0 && GridTS <=0)
                     )
                  && (qdc >0 || MACD_Xtr_cl_on || ChannelsFIBO_MTF_AD_EA_cl_on || ChannelsFIBO_v2_MTF_AD_EA_cl_on || Envelopes_cl_on || Stochastic_cl_on || iMA_cl_on || MA_Kiosotto_cl_on || ATR_Channels_cl_on)
                  && (   qdc<=0  
                     || ( reverse && Quantum_cl_buy>0) 
                     || (!reverse && Quantum_cl_sell>0) 
                     )   
                  && (  !Stochastic_cl_on 
                     || (Stochastic_cl<Stochastic_OS_cl) 
                     )
                  && (  !Pfe_cl_on
                     || (Pfe_cl < - Pfe_Level_cl)
                     )   
                  && (  !iMA_cl_on
                        || (Bid > iMA_cl)
                     )   
                  && (  !MACD_Xtr_cl_on 
                     || ( reverse && MACD_Xtr_3_cl>0) 
                     || (!reverse && MACD_Xtr_4_cl<0)
                     )
                  && (   !ChannelsFIBO_MTF_AD_EA_cl_on  
                     || ( reverse && !i_open_cl && High[1] > ChannelsFIBO_MTF_cl_0) 
                     || ( reverse &&  i_open_cl && High[1] > ChannelsFIBO_MTF_cl_1) 
                     || (!reverse && !i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_1)
                     || (!reverse &&  i_open_cl && Low[1]  < ChannelsFIBO_MTF_cl_0)
                     )
                  && (  !ChannelsFIBO_v2_MTF_AD_EA_cl_on    
                     || ( reverse && !i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_0) 
                     || ( reverse &&  i_open_v2_cl && High[1] > ChannelsFIBO_v2_cl_1) 
                     || (!reverse && !i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_1)
                     || (!reverse &&  i_open_v2_cl && Low[1]  < ChannelsFIBO_v2_cl_0)
                     )    
                  && (   !Envelopes_cl_on  
                     || ( reverse && !env_open_cl && High[1] > Envelopes_cl_UP)
                     || (!reverse && !env_open_cl && Low [1] < Envelopes_cl_LO)
                     || ( reverse && env_open_cl && High[1] > Envelopes_cl_LO)
                     || (!reverse && env_open_cl && Low [1] < Envelopes_cl_UP)
                    )
                  && (  !ATR_Channels_cl_on  
                     || (!reverse && !ATR_Channels_op_cl && Low[1]  < ATR_cl_1) 
                     || (!reverse &&  ATR_Channels_op_cl && Low[1]  < ATR_cl_0)
                     || ( reverse && !ATR_Channels_op_cl && High[1] > ATR_cl_0)
                     || ( reverse &&  ATR_Channels_op_cl && High[1] > ATR_cl_1)
                     )
                  && (  !MA_Kiosotto_cl_on 
                     || (!reverse && MA_Kiosotto_cl_sell>MA_Kiosotto_MA_cl)
                     || ( reverse && MA_Kiosotto_cl_buy >MA_Kiosotto_MA_cl)
                     )      
                  )
               )
            )
         )
      )
      CloseNormal();
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseNormal()
{
   int   count1 = openorders;
   int   count=1;
   for(; count!=0;) // ðàñ÷åò êîë-âà çàêðûâàåìûõ îðäåðîâ
   {
      count=0;
      for(int trade=OrdersTotal()-1; trade>=0; trade--) //
      {                                                                       //
         if(!OrderSelect(trade,SELECT_BY_POS,MODE_TRADES))continue;                        //
         if(OrderMagicNumber()==mn) count++;       //
      }                                                                       //
      if(count==0)
      {
//         barNext = false;
         GridTS=0;
         prevorderprice=0;
         initialstartbuy=0;
         initialstartsell=0;
         lastorderbar=0;
         countbuy=0;
         countsell=0;
         openorders=0;
         grid1trades=0;
         grid2trades=0;
         grid3trades=0;
         grid4trades=0;
         thewaitbuy=0;
         thewaitsell=0;
         DeleteLines();
         DeleteLinesTS();
         FirstLot=0;
         if(cyc_var==1)
         {
            if(numcycles>0)  cycles+=1;
            if(!fulltime)
            {
               if(cyc1>0 && curtime>=open1 && curtime<close1 && open1 < close1)c1+=1;
               if(cyc2>0 && curtime>=open2 && curtime<close2 && open2 < close2)c2+=1;
               if(cyc3>0 && curtime>=open3 && curtime<close3 && open3 < close3)c3+=1;
            }
         }
         return;
      }
      for(int c=OrdersTotal()-1;c>=0;c--)
      {
         if(!OrderSelect(c,SELECT_BY_POS,MODE_TRADES))
            continue;
         if(OrderMagicNumber()==mn)
         {
            if(IsTrAll(MaxWaiting)>=0)
            {
               RefreshRates();
               if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),Slip_cl,0))            
               {
                  Alert("OrderClose Error: ",GetLastError());
                  if(count1 == openorders)
                  {  
                     Alert("GridClose Error: ",GetLastError());
                     return;
                  }
               }
               else count1--;
            }
            else 
               if(count1 == openorders)
                  return;
         }
      }   
   }
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

void DrawGrid(double price,string dir)
  {
   Alert("Were the grid lines drawn?");
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   if(dir=="Buy")
     {
      ObjectCreate(0,"Initial Grid",OBJ_HLINE,0,iTime(Symbol(),1,0),price);
      ObjectCreate(0,"Grid 1",OBJ_HLINE,0,iTime(Symbol(),1,0),price-(grid1size*Point*digits));
      ObjectCreate(0,"Grid 2",OBJ_HLINE,0,iTime(Symbol(),1,0),price-((grid1size+grid2size)*Point*digits));
      ObjectCreate(0,"Grid 3",OBJ_HLINE,0,iTime(Symbol(),1,0),price-((grid1size+grid2size+grid3size)*Point*digits));
      ObjectCreate(0,"Grid 4",OBJ_HLINE,0,iTime(Symbol(),1,0),price-((grid1size+grid2size+grid3size+grid4size)*Point*digits));
     }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   if(dir=="Sell")
     {
      ObjectCreate(0,"Initial Grid",OBJ_HLINE,0,iTime(Symbol(),1,0),price);
      ObjectCreate(0,"Grid 1",OBJ_HLINE,0,iTime(Symbol(),1,0),price+(grid1size*Point*digits));
      ObjectCreate(0,"Grid 2",OBJ_HLINE,0,iTime(Symbol(),1,0),price+((grid1size+grid2size)*Point*digits));
      ObjectCreate(0,"Grid 3",OBJ_HLINE,0,iTime(Symbol(),1,0),price+((grid1size+grid2size+grid3size)*Point*digits));
      ObjectCreate(0,"Grid 4",OBJ_HLINE,0,iTime(Symbol(),1,0),price+((grid1size+grid2size+grid3size+grid4size)*Point*digits));
     }
   MessageBoxA(0,"Got the 1000th tick!","Pause...",64);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DeleteLines()
  {
   ObjectDelete(0,"Initial Grid");
   ObjectDelete(0,"Grid 1");
   ObjectDelete(0,"Grid 2");
   ObjectDelete(0,"Grid 3");
   ObjectDelete(0,"Grid 4");
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DeleteLinesTS()
  {
   if(GridTSon > 0)ObjectSet("TrailingStop", OBJPROP_PRICE1, 0); //îòîáðàæåíèå ðàçðåøåíî? - ðèñóåì ëèíèþ TrailingStop ñåòêè
   else ObjectDelete("TrailingStop");
   return;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CreateButton()
  {
   ObjectCreate(ChartID(),"start",OBJ_BUTTON,0,0,0);
   ObjectSetInteger(ChartID(),"start",OBJPROP_COLOR,clrWhite);
   ObjectSetInteger(ChartID(),"start",OBJPROP_BGCOLOR,clrGreen);
   ObjectSetInteger(ChartID(),"start",OBJPROP_CORNER,CORNER_LEFT_LOWER);
   ObjectSetInteger(ChartID(),"start",OBJPROP_XSIZE,100);
   ObjectSetInteger(ChartID(),"start",OBJPROP_YSIZE,20);
   ObjectSetInteger(ChartID(),"start",OBJPROP_STATE,false);
   ObjectSetString(ChartID(),"start",OBJPROP_FONT,"Arial");
   ObjectSetString(ChartID(),"start",OBJPROP_TEXT,"Start next cycle");
   ObjectSetInteger(ChartID(),"start",OBJPROP_FONTSIZE,8);
   ObjectSetInteger(ChartID(),"start",OBJPROP_SELECTABLE,0);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CreateManualButton()
  {
   ObjectCreate(ChartID(),"manual",OBJ_BUTTON,0,0,0);
   ObjectSetInteger(ChartID(),"manual",OBJPROP_COLOR,clrWhite);
   ObjectSetInteger(ChartID(),"manual",OBJPROP_BGCOLOR,clrRed);
   ObjectSetInteger(ChartID(),"manual",OBJPROP_CORNER,CORNER_RIGHT_LOWER);
   ObjectSetInteger(ChartID(),"manual",OBJPROP_XSIZE,100);
   ObjectSetInteger(ChartID(),"manual",OBJPROP_YSIZE,20);
   ObjectSetInteger(ChartID(),"manual",OBJPROP_STATE,false);
   ObjectSetString(ChartID(),"manual",OBJPROP_FONT,"Arial");
   ObjectSetString(ChartID(),"manual",OBJPROP_TEXT,"Close All Trades");
   ObjectSetInteger(ChartID(),"manual",OBJPROP_FONTSIZE,8);
   ObjectSetInteger(ChartID(),"manual",OBJPROP_SELECTABLE,0);
   return;
  }
//+------------------------------------------------------------------+


//+---------------------Ïîäñ÷åò îðäåðîâ â ðûíêå----------------------+
int CountTrades (int otype)
{
   int count = 0;
   for (int trade = OrdersTotal()-1; trade>=0; trade--)
   {
      if(!OrderSelect (trade, SELECT_BY_POS, MODE_TRADES))continue;
      if (OrderMagicNumber() == mn && OrderType() == otype) count++;

   }
   return (count);
}


//+--------------------  Ïðîâåðêà êàíàëà  ---------------------------------------------+

/////////////////////////////////////////////////////////////////////////////////
int IsTrAll(uint MaxWaiting_sec)
  {
    // ïðîâåðÿåì, ñâîáîäåí ëè òîðãîâûé ïîòîê
    if(!IsTradeAllowed())
      {
        uint StartWaitingTime = GetTickCount();
        if(debug) Print("Òîðãîâûé ïîòîê çàíÿò! Æä¸ì, ïîêà îí îñâîáîäèòüñÿ...");
        // áåñêîíå÷íûé öèêë
        while(true)
          {
            // åñëè ýêñïåðò áûë îñòàíîâëåí ïîëüçîâàòåëåì, ïðåêðàùàåì ðàáîòó
            if(IsStopped()) 
              { 
                if(debug) Print("Ýêñïåðò áûë îñòàíîâëåí ïîëüçîâàòåëåì!"); 
                return(-1); 
              }
            // åñëè îæèäàíèå äëèòñÿ äîëüøå âðåìåíè, óêàçàííîãî â ïåðåìåííîé 
            // MaxWaiting_sec, òîæå ïðåêðàùàåì ðàáîòó
            if(GetTickCount() - StartWaitingTime > MaxWaiting_sec * 1000)
              {
                if(debug) Print("Ïðåâûøåí ëèìèò îæèäàíèÿ (" + IntegerToString(MaxWaiting_sec,3) + " ñåê.)!");
                return(-2);
              }
            // åñëè òîðãîâûé ïîòîê îñâîáîäèëñÿ,
            if(IsTradeAllowed())
              {
                if(debug)Print("Òîðãîâûé ïîòîê îñâîáîäèëñÿ!");
                return(0);
              }
            // åñëè íè îäíî èç óñëîâèé îñòàíîâêè öèêëà íå ñðàáîòàëî, "æä¸ì" 0,1 
            // ñåêóíäû è íà÷èíàåì ïðîâåðêó ñíà÷àëà
            Sleep(100);
          }
      }
    else
      {
        if(debug) Print("Òîðãîâûé ïîòîê ñâîáîäåí!");
        return(1);
      }
   return(-3);
  }



//+------------------------------------------------------------------+
//                      ðàñ÷åò öåíû ñåòêè                            +
//+------------------------------------------------------------------+
void Gridprice (int otype)
{
   double order_lots = 0;
   double price = 0;
   double profit = 0;
 
   for (int i = OrdersTotal()-1; i >= 0; i--)                     // öèêë ïî êîëè÷åñòâó îðäåðîâ    ----------------
   {                                                              //                                              /
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))             // âûáîð îðäåðà                                 /
      {                                                           //                                              /
         if (OrderMagicNumber() == mn && OrderType() == otype) // åñëè îðäåð íàø                               /
         {                                                        //                                              /
            order_lots += OrderLots();                            //                                              /
            profit += OrderProfit();
            if (otype ==OP_SELL)    price += OrderOpenPrice() * OrderLots() + (OrderSwap() + OrderCommission()) * Point;
            if (otype ==OP_BUY)     price += OrderOpenPrice() * OrderLots() - (OrderSwap() + OrderCommission()) * Point;
         }                                                        //                                              /
      }                                                           //                                              /
   }                                                              // ----------------------------------------------
   if ((otype ==OP_SELL) && (order_lots>0))       // öåíà ñåòêè SELL
      {
       avgpriceSELL = NormalizeDouble ((price / order_lots), Digits);       // öåíà ñåòêè SELL
       avgpriceSELLlot = order_lots;
       profitSELL =profit;
      }
   if ((otype ==OP_BUY)  && (order_lots>0))       // öåíà ñåòêè BUY
      {
       avgpriceBUY = NormalizeDouble ((price / order_lots), Digits);       // öåíà ñåòêè BUY
       avgpriceBUYlot = order_lots;
       profitBUY =profit;
      }
}   

//+---------------------Ðàñ÷åò % îò ÀÒÐ----------------------+
double percATR (double otype, int TF, int Period_ATR)
{
   double perc=iATR(Symbol(),TF,Period_ATR,1)*otype/100;
   return (perc);
}    
//+------------------Èíäåêñ áàðà ïîñëåäíåãî îðäåðà------------+
void Lastorderbar()
{
   lastorderbar=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
   {
      if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))     continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
         {
         lastorderbar=iBarShift(Symbol(),tf,OrderOpenTime(),false);
         break;
         }
   }
}

//+------------------Öåíà ïîñëåäíåãî îðäåðà------------+
void Prevorderprice()
{
   for(int i=OrdersTotal()-1;i>=0;i--)
   {
      if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))         continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
      {
         prevorderprice=OrderOpenPrice();
         break;
      }
   }
}




//+------------------Îòêðûòèå îðäåðîâ------------+
void OpenOrder(int otype)
{
   GetLastError(); 
   if (!IsTesting())
   {
      for(int i=OrdersTotal()-1;i>=0;i--)
      {
         if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))     continue;
         if(OrderSymbol()!=Symbol() && OrderMagicNumber()==mn)
         {
            Alert("Ñðàáîòàë ñòîï, ïàðàìåòð Magic Number = ", mn ,"óæå èñïîëüçóåòñÿ íà èíñòðóìåíòå - ",OrderSymbol());
            ExpertRemove(); int b = 0; int stop_ea = 1/b;
         }
      }
   }      
   if(otype==OP_BUY)
   {
      ticket=0;
      double newsl=0;
      double newtp=0;
      if(indivsl>0) 
      {
         if (indiv_var == 0)
            newsl = NormalizeDouble(Ask - (indivsl*Point),Digits);
         if (indiv_var == 1)
            newsl = NormalizeDouble(Ask - percATR(indivsl, indiv_ATR_TF, indiv_Period_sl),Digits);   
      }
      if(indivtp>0) 
      {
         if (indiv_var == 0)
            newtp = NormalizeDouble(Ask+(indivtp*Point),Digits);
         if (indiv_var == 1)
            newtp = NormalizeDouble(Ask + percATR(indivtp, indiv_ATR_TF, indiv_Period_tp),Digits);   
      }
      if(IsTrAll(MaxWaiting)>=0)
      {
         RefreshRates();
         ticket=OrderSend(Symbol(),OP_BUY,lots,Ask,Slip_op,newsl,newtp,comm,mn,0,0);
      }
      if(debug && ticket<=-1)  
         Alert("OrderSend Error: ",GetLastError());
      if(ticket>0)  
      {
//+----------------------------------- òåñòîâûé ðåæèì ---------------------------------
         if (IsTesting()) 
         {
            if(MAX_EQUITY_DD < Test_Free_Margin - AccountFreeMargin())
               MAX_EQUITY_DD = Test_Free_Margin - AccountFreeMargin();
            if((AccFreeMargin > 0.0) && (AccountFreeMargin() < Test_Free_Margin) && (MAX_EQUITY_DD > AccFreeMargin)) 
            {
               Alert("Ñòîï, ñòàðòîâàÿ ìàðæà= ", NormalizeDouble(Test_Free_Margin,2), " îñòàòîê ", 
                  NormalizeDouble(AccountFreeMargin(),2), " ïðåâûøåí íà÷àëüíûé äåïîçèò ÅÀ íà ",               
                  NormalizeDouble(Test_Free_Margin -AccountFreeMargin()- AccFreeMargin, 2),
                  " ïðè AccFreeMargin=", AccFreeMargin);
               ExpertRemove(); int b = 0; int stop_ea = 1/b; // Äåëåíèå íà 0 äëÿ íåøòàòíîãî çàâåðøåíèÿ òåñòèðîâàíèÿ 
            }      
         }
//+------------------------------------------------------------------------------------
         barNext=false;
         countbuy++;
         openorders++;
         lastorderbar=0;
         Virt_Order_buy =0;
         ObjectSet("Virt_Order_BUY",OBJPROP_PRICE1,Virt_Order_buy);
         Quantum_op_buy =0;
         qde_bars_count_buy = 0;
         ObjectDelete("Quantum_buy");
         if(cyc_var == 0 && countbuy==1)
         {
            if(numcycles>0)   cycles+=1;
            if(!fulltime)
            {   
               if(cyc1>0 && curtime>=open1 && curtime<close1 && open1 < close1)c1+=1;   
               if(cyc2>0 && curtime>=open2 && curtime<close2 && open2 < close2)c2+=1;
               if(cyc3>0 && curtime>=open3 && curtime<close3 && open3 < close3)c3+=1;
            }
         }
      }   
   }
   if(otype==OP_SELL)
   {
      ticketn=0;
      double newsl=0;
      double newtp=0;
      if(indivsl>0) 
      {
         if (indiv_var == 0)
            newsl = NormalizeDouble(Bid+(indivsl*Point),Digits);
         if (indiv_var == 1)
            newsl = NormalizeDouble(Bid+ percATR(indivsl, indiv_ATR_TF, indiv_Period_sl),Digits);   
      }
      if(indivtp>0) 
      {
         if (indiv_var == 0)
            newtp=NormalizeDouble(Bid-(indivtp*Point),Digits);
         if (indiv_var == 1)
            newtp = NormalizeDouble(Bid - percATR(indivtp, indiv_ATR_TF, indiv_Period_tp),Digits);   
      }
      if(IsTrAll(MaxWaiting)>=0)
      {
         RefreshRates();
         ticketn=OrderSend(Symbol(),OP_SELL,lots,Bid,Slip_op,newsl,newtp,comm,mn,0,0);
      }
      if(debug && ticketn<=-1)  
         Alert("OrderSend Error: ",GetLastError());
      if(ticketn>0)  
      {
//+----------------------------------- òåñòîâûé ðåæèì ---------------------------------
         if (IsTesting()) 
         {
            if(MAX_EQUITY_DD < Test_Free_Margin - AccountFreeMargin())
            {
               MAX_EQUITY_DD = Test_Free_Margin - AccountFreeMargin();
               Print("MAX_EQUITY_DD = ",MAX_EQUITY_DD);
            }
            if((AccFreeMargin > 0.0) && (AccountFreeMargin() < Test_Free_Margin) && (MAX_EQUITY_DD > AccFreeMargin)) 
            {
               Alert("Ñðàáîòàë ñòîï, ïðè ñòàðòîâîé ìàðæå â ", NormalizeDouble(Test_Free_Margin,2), " îñòàòîê ",
                     NormalizeDouble(AccountFreeMargin(),2), " ïðåâûøåí íà÷àëüíûé äåïîçèò ÅÀ â AccFreeMargin=",AccFreeMargin);
               int b = 0; 
               int stop_ea = 1/b;
            }      
         }
//+------------------------------------------------------------------------------------
         barNext=false;
         countsell++;
         lastorderbar=0;
         openorders++;
         Virt_Order_sell=0;
         ObjectSet("Virt_Order_SELL",OBJPROP_PRICE1,Virt_Order_sell);
         Quantum_op_sell =0;
         qde_bars_count_sell = 0;
         ObjectDelete("Quantum_sell");
         if(cyc_var == 0 && CountTrades(OP_SELL)==1)
         {
            if(numcycles>0)   cycles+=1;
            if(!fulltime)
            {   
               if(cyc1>0 && curtime>=open1 && curtime<close1 && open1 < close1)c1+=1;   
               if(cyc2>0 && curtime>=open2 && curtime<close2 && open2 < close2)c2+=1;
               if(cyc3>0 && curtime>=open3 && curtime<close3 && open3 < close3)c3+=1;
            }
         }
      }   
   }
}
//+------------------------------------------------------------------+
double GetRecoveryFactor() 
{
  double Res = 0;
  if (MAX_EQUITY_DD != 0)
      Res = TesterStatistics(STAT_PROFIT) / TesterStatistics(STAT_EQUITY_DD);
  return(Res);
}
//+------------------------------------------------------------------+
void GX_Price()
{
   if (GX_price_var == 2)
   {
      GX_price_buy   =  GX_Price_buy;
      GX_price_sell  =  GX_Price_sell;
      return;
   }    
   if (curtime >= GX_time)
      GX_price = iOpen(NULL, 1, iBarShift(NULL,1,GX_time,false));
   if (GX_price > 0)
   {
      if (GX_price_var == 0)
      {
         if (GX_points_buy > 0)
            GX_price_buy = GX_price - GX_points_buy/MP10D; 
         else
            GX_price_buy = GX_price - GX_points/MP10D; 
         if (GX_points_sell > 0)
            GX_price_sell = GX_price + GX_points_sell/MP10D; 
         else
            GX_price_sell = GX_price + GX_points/MP10D; 
      }
      if (GX_price_var == 1)
      {
         bars_GX_ATR = iTime (NULL, GX_ATR_TF,1);
         GX_ATR = percATR (GX_ATR_perc,GX_ATR_TF,GX_ATR_Period);
         GX_price_buy   = GX_price - GX_ATR; 
         GX_price_sell  = GX_price + GX_ATR; 
      }
   }               
}
