//+------------------------------------------------------------------+
//|                                    Season Trap v1.4.3.mq4 |
//|          Copyright 2015, Silentspec Megamozg Intergalactic Corp. |
//+------------------------------------------------------------------+

#property copyright "Copyright 2015, Silentspec Megamozg Intergalactic Corp."
#property version   "1.4.3"


#define OP_ALL 100
#define OP_ALL_PROFIT 200
#define OP_ALL_LOSS -200
#define OP_ALL_BUY 20
#define OP_ALL_SELL -20

extern string              Settings01 =                  "====Служебные настройки====";
input ENUM_TIMEFRAMES      WorkPeriod =                  PERIOD_H1;
extern string              ExpertName =                  "Season Trap v1.4.3";
extern int                 Magic=0;
extern int                 MaxDayEnterLag=              1;
extern int                 MaxDayExitLag =               1;

extern string              Settings021="====Открывать сделки в пятницу====";
extern bool                Friday_Open=true;
//extern bool                Friday_Open_All_Weekends=False;
extern int                 Friday_Open_Hour=23;
extern string              Settings02="====Закрывать сделки в пятницу====";
extern bool                Friday_Close=true;
//extern bool                Friday_Close_All_Weekends=False;
extern int                 Friday_Close_Hour=22;

extern string              Settings03="====Настройки SL и TP====";
extern int                 SL =                          60;            // Величина фикс стопа
extern double              TPProc =                      100;           // Величина в % от стопа

extern string              Settings04="====Настройки ММ====";
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum MMVAR
  {
   MMVAR0=0,                            //  Фиксированный лот
   MMVAR1=1,                            //  Фиксированный процент
   MMVAR2=2,                            //  Фиксированная пропорция Ральфа Винса
  };
input MMVAR                LotVariant=0;
extern double              FixLot =                      0.1;                 // Фиксированный лот
extern double              Risk =                        3;                   // Риск в процентах от депозита
extern double              MoneyForMinLot  =             200;                 // Денег депозита на минимальный лот

extern string              Settings05="====БУ====";
extern bool                UseBE=false;
extern int                 BELevel=20;
extern int                 BEPlusPips=5;

extern string              Settings06="====Прочие торговые настройки====";
extern int                 Slippage=1;
extern int                 RetryAttempts =               3;                               // Кол-во попыток открыть/закрыть/модифицировать ордер
extern int                 RetryAttemptsPause =          60;                              // Количество секунд между попытками
bool                       ECNAccount =                  true;                            // Включить, если счет ECN
extern bool                UseComments=                 false;

extern string              Settings07 =                  "====Расписание Sell====";
extern string              Settings08 =                  "====Время открытия / закрытия====";

extern int                 HourOpenSell=1;                               // Время открытия ордеров Sell
extern int                 HourCloseSell=1;                              // Время закрытия ордеров Sell

extern string              Settings09="====Даты открытия / закрытия====";

extern int sMonthOpen1=0;
extern int sDayOpen1=0;
extern int sMonthClose1=0;
extern int sDayClose1=0;

extern int sMonthOpen2=0;
extern int sDayOpen2=0;
extern int sMonthClose2=0;
extern int sDayClose2=0;

extern int sMonthOpen3=0;
extern int sDayOpen3=0;
extern int sMonthClose3=0;
extern int sDayClose3=0;

extern int sMonthOpen4=0;
extern int sDayOpen4=0;
extern int sMonthClose4=0;
extern int sDayClose4=0;

extern int sMonthOpen5=0;
extern int sDayOpen5=0;
extern int sMonthClose5=0;
extern int sDayClose5=0;

extern int sMonthOpen6=0;
extern int sDayOpen6=0;
extern int sMonthClose6=0;
extern int sDayClose6=0;

extern int sMonthOpen7=0;
extern int sDayOpen7=0;
extern int sMonthClose7=0;
extern int sDayClose7=0;

extern int sMonthOpen8=0;
extern int sDayOpen8=0;
extern int sMonthClose8=0;
extern int sDayClose8=0;

extern int sMonthOpen9=0;
extern int sDayOpen9=0;
extern int sMonthClose9=0;
extern int sDayClose9=0;

extern int sMonthOpen10=0;
extern int sDayOpen10=0;
extern int sMonthClose10=0;
extern int sDayClose10=0;

extern int sMonthOpen11=0;
extern int sDayOpen11=0;
extern int sMonthClose11=0;
extern int sDayClose11=0;

extern int sMonthOpen12=0;
extern int sDayOpen12=0;
extern int sMonthClose12=0;
extern int sDayClose12=0;

extern int sMonthOpen13=0;
extern int sDayOpen13=0;
extern int sMonthClose13=0;
extern int sDayClose13=0;

extern int sMonthOpen14=0;
extern int sDayOpen14=0;
extern int sMonthClose14=0;
extern int sDayClose14=0;

extern int sMonthOpen15=0;
extern int sDayOpen15=0;
extern int sMonthClose15=0;
extern int sDayClose15=0;

extern int sMonthOpen16=0;
extern int sDayOpen16=0;
extern int sMonthClose16=0;
extern int sDayClose16=0;

extern int sMonthOpen17=0;
extern int sDayOpen17=0;
extern int sMonthClose17=0;
extern int sDayClose17=0;

extern int sMonthOpen18=0;
extern int sDayOpen18=0;
extern int sMonthClose18=0;
extern int sDayClose18=0;

extern int sMonthOpen19=0;
extern int sDayOpen19=0;
extern int sMonthClose19=0;
extern int sDayClose19=0;

extern int sMonthOpen20=0;
extern int sDayOpen20=0;
extern int sMonthClose20=0;
extern int sDayClose20=0;

extern string              Settings10 =                  "====Расписание Buy====";
extern string              Settings11 =                  "====Время открытия / закрытия====";
extern int                 HourOpenBuy  =                1;                               // Время открытия ордеров Buy
extern int                 HourCloseBuy  =               1;                               // Время закрытия ордеров Buy

extern string              Settings12="====Даты открытия / закрытия====";
extern int bMonthOpen1=0;
extern int bDayOpen1=0;
extern int bMonthClose1=0;
extern int bDayClose1=0;

extern int bMonthOpen2=0;
extern int bDayOpen2=0;
extern int bMonthClose2=0;
extern int bDayClose2=0;

extern int bMonthOpen3=0;
extern int bDayOpen3=0;
extern int bMonthClose3=0;
extern int bDayClose3=0;

extern int bMonthOpen4=0;
extern int bDayOpen4=0;
extern int bMonthClose4=0;
extern int bDayClose4=0;

extern int bMonthOpen5=0;
extern int bDayOpen5=0;
extern int bMonthClose5=0;
extern int bDayClose5=0;

extern int bMonthOpen6=0;
extern int bDayOpen6=0;
extern int bMonthClose6=0;
extern int bDayClose6=0;

extern int bMonthOpen7=0;
extern int bDayOpen7=0;
extern int bMonthClose7=0;
extern int bDayClose7=0;

extern int bMonthOpen8=0;
extern int bDayOpen8=0;
extern int bMonthClose8=0;
extern int bDayClose8=0;

extern int bMonthOpen9=0;
extern int bDayOpen9=0;
extern int bMonthClose9=0;
extern int bDayClose9=0;

extern int bMonthOpen10=0;
extern int bDayOpen10=0;
extern int bMonthClose10=0;
extern int bDayClose10=0;

extern int bMonthOpen11=0;
extern int bDayOpen11=0;
extern int bMonthClose11=0;
extern int bDayClose11=0;

extern int bMonthOpen12=0;
extern int bDayOpen12=0;
extern int bMonthClose12=0;
extern int bDayClose12=0;

extern int bMonthOpen13=0;
extern int bDayOpen13=0;
extern int bMonthClose13=0;
extern int bDayClose13=0;

extern int bMonthOpen14=0;
extern int bDayOpen14=0;
extern int bMonthClose14=0;
extern int bDayClose14=0;

extern int bMonthOpen15=0;
extern int bDayOpen15=0;
extern int bMonthClose15=0;
extern int bDayClose15=0;

extern int bMonthOpen16=0;
extern int bDayOpen16=0;
extern int bMonthClose16=0;
extern int bDayClose16=0;

extern int bMonthOpen17=0;
extern int bDayOpen17=0;
extern int bMonthClose17=0;
extern int bDayClose17=0;

extern int bMonthOpen18=0;
extern int bDayOpen18=0;
extern int bMonthClose18=0;
extern int bDayClose18=0;

extern int bMonthOpen19=0;
extern int bDayOpen19=0;
extern int bMonthClose19=0;
extern int bDayClose19=0;

extern int bMonthOpen20=0;
extern int bDayOpen20=0;
extern int bMonthClose20=0;
extern int bDayClose20=0;

extern string              Settings076 =                  "====Настройки кривой баланса====";
extern bool                UseBalanceCorr =              true; //Включитить умный MM от Silentspec
extern bool                UseMABalanceCorr =            true;
extern int                 MAMMPer =                     14;
extern double              MADev =                       1.0;
extern bool                UseOSCBalanceCorr =           true;
extern int                 CCIMMPer =                    7;
extern double              CCIMMLevel =                  40;
extern double              Coeff1 =                      1.6; 
extern double              Coeff2 =                      1.4;
extern double              Coeff3 =                      1.2;
extern double              Coeff4 =                      0.8; 
extern double              Coeff5 =                      0.6;
extern double              Coeff6 =                      0.4;

double InitResult=INIT_FAILED;
double StopLevel,MinLot,MaxLot,LotStep=-1,PointValue,BaseLot;
int PriceDigits;

double                     TralStep=                    0.1;
int                        MinTral =                     5;
int DealsBuy[20][4];
int DealsSell[20][4];
int AllDeals[40];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(RetryAttempts==0) RetryAttempts=10;
   RetryAttemptsPause*=1000;
   fArrowsRest();
   StopLevel   = MarketInfo(Symbol(),MODE_STOPLEVEL);
   MinLot      = MarketInfo(Symbol(),MODE_MINLOT);
   MaxLot      = MarketInfo(Symbol(),MODE_MAXLOT);
   LotStep     = MarketInfo(Symbol(),MODE_LOTSTEP);
   if(LotStep<0) LotStep=0.01;
   PointValue  = SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE);
   PriceDigits = SymbolInfoInteger(Symbol(),SYMBOL_DIGITS);
   if(PriceDigits==5 || PriceDigits==3)
     {
      SL*=10;
      Slippage*=10;
      BELevel*=10;
      BEPlusPips*=10;
     }
   InitDeals();
   EAComment(" Советник "+ExpertName+" начал работу на паре "+_Symbol+" с магиком "+IntegerToString(Magic));

   return(InitResult);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   switch(_UninitReason)
     {
      case REASON_ACCOUNT:
         EAComment(" Советник остановлен. Пара "+_Symbol+". Смена аккаунта.");
         break;
      case REASON_CHARTCHANGE:
         EAComment(" Советник остановлен. Пара "+_Symbol+". Смена таймфрейма.");
         break;
      case REASON_CHARTCLOSE:
         EAComment(" Советник остановлен. Пара "+_Symbol+". Закрытие графика.");
         break;
      case REASON_PARAMETERS:
         EAComment(" Советник остановлен. Пара "+_Symbol+". Смена параметров.");
         break;
      case REASON_RECOMPILE:
         EAComment(" Советник остановлен. Пара "+_Symbol+". Советник декомпилирован.");
         break;
      case REASON_REMOVE:
         EAComment(" Советник остановлен. Пара "+_Symbol+". Советник был удален с графика.");
         break;
      case REASON_TEMPLATE:
         EAComment(" Советник остановлен. Пара "+_Symbol+". Новый шаблон на графике.");
         break;
      default:
         EAComment(" Советник остановлен. Пара "+_Symbol);
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(IsNewBar(0,WorkPeriod))
     {
      fArrowsRest();
      if(OrdExist(OP_BUY)==0 && OrdExist(OP_SELL)==0 && IndicatorEnterSignalBuy())
        {
         EAComment("Открываем покупку");
         OpenOrder(OP_BUY,Ask);
        }
      if(OrdExist(OP_BUY)==0 && OrdExist(OP_SELL)==0 && IndicatorEnterSignalSell())
        {
         EAComment("Открываем продажу");
         OpenOrder(OP_SELL,Bid);
        }
      // Если есть рыночный селл
      if(OrdExist(OP_SELL)>0)
        {
         // Смотрим возможность выхода из селла
         if(SignalExit(OP_SELL))
           {
            EAComment("Условие выхода из продаж. Закрываем ордера селл.");
            CloseAllOrders(OP_SELL);
            return;
           }
         if(UseBE) TrailingBE();
        }
      // Если есть рыночный бай
      if(OrdExist(OP_BUY)>0)
        {
         // Смотрим возможность выхода из бая
         if(SignalExit(OP_BUY))
           {
            EAComment("Условие выхода из покупок. Закрываем ордера бай.");
            CloseAllOrders(OP_BUY);
            return;
           }
         if(UseBE) TrailingBE();
        }
     }
   informer();
   return;
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Сигнал на выход из позиций                                       |
//+------------------------------------------------------------------+

bool ExitFriday(int month,int day)
  {
// нужно делать проверку на количество дней в месяце и смотреть на стык двух месяцев
// 30 - пятница    31|1 - выходные , а закрытие 1го числа
   if(Friday_Close && DayOfWeek()==5 && Friday_Close_Hour==Hour())
     {

      // проверяем что это следующий месяц
      if(Month()+1==month)
        {
         // нужно проверить день выхода субота это или воскресенье
         datetime date=StrToTime(Year()+"."+month+"."+day);
         int day_number=TimeDayOfWeek(date);

         // закрытие попадает на выходные нового месяца
         //if(Friday_Close_All_Weekends)
         // {
         if(Day()>=28 && Day()<=31 && (day==1 || day==2) && ((day_number==0 && MaxDayExitLag==0) || (day_number==6 && MaxDayExitLag==1)))
            return(true);
         //}
/*else
           {
            if(Day()>=28 && Day()<=31 && (day==1) && (day_number==6 && MaxDayEnterLag==1))
               return(true);
           }*/
        }

      // проверяем что условие на выход для текущего месяца 
      if(Month()==month)
         // проверяем попадает ли закрытие на пятницу или выходные
         // if(Friday_Close_All_Weekends)
         // {
         if((Day()+2==day || Day()+1==day || Day()+1==day+MaxDayExitLag || Day()+2==day+MaxDayExitLag) && Day()+2<=day+MaxDayExitLag)
            return(true);
      // }
/*else
        {
         if((Day()+1==day || Day()+1==day+MaxDayExitLag) && Day()+1<=day+MaxDayExitLag)
            return(true);
        }*/

     }

   return (false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool EnterFriday(int month,int day)
  {
// нужно делать проверку на количество дней в месяце и смотреть на стык двух месяцев
// 30 - пятница    31|1 - выходные , а открытие 1го числа
   if(Friday_Open && DayOfWeek()==5 && Friday_Open_Hour==Hour())
     {

      // проверяем что это следующий месяц
      if(Month()+1==month)
        {
         // нужно проверить день входа субота это или воскресенье
         datetime date=StrToTime(Year()+"."+month+"."+day);
         int day_number=TimeDayOfWeek(date);

         // Открытие попадает на выходные нового месяца
        // if(Friday_Open_All_Weekends)
          // {
            if(Day()>=28 && Day()<=31 && (day==1 || day==2) && ((day_number==0 && MaxDayEnterLag==0) || (day_number==6 && MaxDayEnterLag==1)))
               return(true);
           //}
         /*else
           {
            if(Day()>=28 && Day()<=31 && (day==1) && (day_number==6 && MaxDayEnterLag==1))
               return(true);
           }*/
        }

      // проверяем что условие на выход для текущего месяца 
      if(Month()==month)
         // проверяем попадает ли открытие на пятницу или выходные
        // if(Friday_Open_All_Weekends)
          // {
            if((Day()+2==day || Day()+1==day || Day()+1==day+MaxDayEnterLag || Day()+2==day+MaxDayEnterLag) && Day()+2<=day+MaxDayEnterLag)
               return(true);
           //}
     /* else
        {
         if((Day()+1==day || Day()+1==day+MaxDayEnterLag) && Day()+1<=day+MaxDayEnterLag)
            return(true);
        }*/
     }
   return(false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
/*
bool ExitMonday(int month, int day)
{   
    // нужно делать проверку на количество дней в месяце и смотреть на стык двух месяцев
    // если понедельник 1 число а закрытие было на выходных 31 или 30 то мы не закроем сделку в понедельник

    // проверяем что условие на выход для текущего месяца 
    if (Month() == month)
      // проверяем попадает ли дата ближайщих выходных на дату выхода из сделки    
      if (Monday_Close && DayOfWeek()== 1 && Monday_Close_Hour == Hour() 
          && ( Day()-2 == day || Day()-1 == day || Day()-1 == day+MaxDayExitLag || Day()-2 == day+MaxDayExitLag ))
          return(true);

 return (false);
}
*/

bool SignalExit(int dir)
  {
   int i=0;
   if(dir==OP_SELL)
     {
      for(i=0;i<20;i++)
        {
         // пропускаем не заполненные значения
         if(DealsSell[i][2]==0 || DealsSell[i][3]==0)
            continue;

         if((DealsSell[i][2]==Month() && DealsSell[i][3]==Day() && HourCloseSell==Hour())
            || (DealsSell[i][2]==Month() && Day()>=DealsSell[i][3] && Day()<=DealsSell[i][3]+MaxDayExitLag && HourCloseSell==Hour())
            || ExitFriday(DealsSell[i][2],DealsSell[i][3]))
           {
            EAComment("Закрываем селл");
            return(true);
           }

        }
     }
   if(dir==OP_BUY)
     {
      for(i=0;i<20;i++)
        {
         //попускаем не заполненные значения
         if(DealsBuy[i][2]==0 || DealsBuy[i][3]==0)
            continue;

         if((DealsBuy[i][2]==Month() && DealsBuy[i][3]==Day() && HourCloseBuy==Hour())
            || (DealsBuy[i][2]==Month() && Day()>=DealsBuy[i][3] && Day()<=DealsBuy[i][3]+MaxDayExitLag && HourCloseBuy==Hour())
            || ExitFriday(DealsBuy[i][2],DealsBuy[i][3]))
           {
            EAComment("Закрываем бай");
            return(true);
           }

        }
     }
   return(false);
  }
//+------------------------------------------------------------------+

bool IndicatorEnterSignalSell()
  {
   int last_sell_close_date=0;
// смотрим время закрытия последнего Sell ордера 
   if(OrdersHistoryTotal()!=0 && OrderSelect(OrdersHistoryTotal()-1,SELECT_BY_POS,MODE_HISTORY))
      if(OrderType()==OP_SELL)
         last_sell_close_date=TimeDay(OrderCloseTime());

   for(int i=0;i<20;i++)
     {
      // пропускаем не заполненные значения
      if(DealsSell[i][0]==0 || DealsSell[i][1]==0)
         continue;

      if((DealsSell[i][0]==Month() && ((DealsSell[i][1]==Day() && (HourOpenSell==Hour() || (HourOpenSell<=Hour() && Hour()<=10)))
         || ((Day()>=DealsSell[i][1] && Day()<=DealsSell[i][1]+MaxDayEnterLag && (HourOpenSell==Hour() || (HourOpenSell<=Hour() && Hour()<=10)))
         && (last_sell_close_date==0 || last_sell_close_date>DealsSell[i][1]+MaxDayEnterLag || DealsSell[i][3]-last_sell_close_date>MaxDayEnterLag))))
         || EnterFriday(DealsSell[i][0],DealsSell[i][1]))
         return(true);


     }
   return(false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IndicatorEnterSignalBuy()
  {
   int last_buy_close_date=0;
// смотрим время закрытия последнего Buy ордера 
   if(OrdersHistoryTotal()!=0 && OrderSelect(OrdersHistoryTotal()-1,SELECT_BY_POS,MODE_HISTORY))
      if(OrderType()==OP_BUY)
         last_buy_close_date=TimeDay(OrderCloseTime());

   for(int i=0;i<20;i++)
     {
      // пропускаем не заполненные значения
      if(DealsBuy[i][0]==0 || DealsBuy[i][1]==0)
         continue;

      if((DealsBuy[i][0]==Month() && ((DealsBuy[i][1]==Day() && (HourOpenBuy==Hour() || (HourOpenBuy<=Hour() && Hour()<=10)))
         || ((Day()>=DealsBuy[i][1] && Day()<=DealsBuy[i][1]+MaxDayEnterLag && (HourOpenBuy==Hour() || (HourOpenBuy<=Hour() && Hour()<=10)))
         && (last_buy_close_date==0 || last_buy_close_date>DealsBuy[i][1]+MaxDayEnterLag || DealsBuy[i][3]-last_buy_close_date>MaxDayEnterLag))))
         || EnterFriday(DealsBuy[i][0],DealsBuy[i][1]))
         return(true);

     }
   return(false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double OnTester()
  {
   double ret=0.0;
   if(TesterStatistics(STAT_BALANCE_DD)>0) ret=TesterStatistics(STAT_PROFIT_FACTOR)*TesterStatistics(STAT_PROFIT)/TesterStatistics(STAT_BALANCE_DD);
   return(ret);
  }
//+------------------------------------------------------------------+
//|  New bar function                                                |
//+------------------------------------------------------------------+
bool IsNewBar(int mode=0,int period=0)
  {
//0 - при первом запуске возвращает true
//1 - при первом запуске ожидает следующий бар
   static datetime tm[10];
   int t=tfA(period);
   if(tm[t]==0&&mode==1) tm[t]=iTime(_Symbol,period,0);
   if(tm[t]==iTime(_Symbol,period,0)) return (false);
   if(period<=PERIOD_H1&&Minute()%period!=0) return (false);
   tm[t]=iTime(_Symbol,period,0);
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int tfA(int tf)
  {
   switch(tf)
     {
      case PERIOD_M1: return (0);
      case PERIOD_M5: return (1);
      case PERIOD_M15: return (2);
      case PERIOD_M30: return (3);
      case PERIOD_H1: return (4);
      case PERIOD_H4: return (5);
      case PERIOD_D1: return (6);
      case PERIOD_W1: return (7);
      case PERIOD_MN1: return (8);
      default: return (9);
     }
  }
//+------------------------------------------------------------------+
//|  Comments                                                        |
//+------------------------------------------------------------------+
void EAComment(string st)
  {
   if(UseComments && !IsOptimization()) Print(st);
   return;
  }
//+------------------------------------------------------------------+
//| Лоты                                                             |
//+------------------------------------------------------------------+
double Lots(double Stop)
  {
   double Lot=0,AccountCurrPrice=1;
   int    orders=OrdersHistoryTotal();
   double TPToSLRatio=0;
   double TPPerc=0;
// Вычисляем коэффициент поправки расчета лота на валюту депозита
   if(StringSubstr(AccountCurrency(), 0, 3) == "JPY") AccountCurrPrice = MarketInfo("USDJPY" + StringSubstr(Symbol(), 6), MODE_BID);
   if(StringSubstr(AccountCurrency(), 0, 3) == "GBP") AccountCurrPrice = 1/MarketInfo("GBPUSD" + StringSubstr(Symbol(), 6), MODE_BID);
   if(StringSubstr(AccountCurrency(), 0, 3) == "EUR") AccountCurrPrice = 1/MarketInfo("EURUSD" + StringSubstr(Symbol(), 6), MODE_BID);
   if(StringSubstr(AccountCurrency(), 0, 3) == "RUB") AccountCurrPrice = MarketInfo("USDRUB" + StringSubstr(Symbol(), 6), MODE_BID);
   if(StringSubstr(AccountCurrency(), 0, 3) == "AUD") AccountCurrPrice = 1/MarketInfo("AUDUSD" + StringSubstr(Symbol(), 6), MODE_BID);
// Считаем лот
   switch(LotVariant)
     {
      case 0:  //  Фиксированный лот
        {
         Lot=FixLot*AccountCurrPrice;
         if(UseBalanceCorr) Lot=Lot*MMCoeff();
         break;
        }
      case 1:  //  Фиксированный процент
        {
         Lot=(AccountFreeMargin()*(Risk/100)/(Stop))*AccountCurrPrice;
         if(UseBalanceCorr) Lot=Lot*MMCoeff();
         break;
        }
      case 2:  //  Фиксированная пропорция
        {
         Lot=(AccountFreeMargin()/MoneyForMinLot)*MinLot*AccountCurrPrice;
         if(UseBalanceCorr) Lot=Lot*MMCoeff();
         break;
        }
     }
// Возвращаем нормализованное значение лота
   return(MathMin(MathMax(MinLot,MathRound(Lot/LotStep)*LotStep),MaxLot));
  }
//+------------------------------------------------------------------+
//| Стопы                                                            |
//+------------------------------------------------------------------+
double StopLoss(int dir,double OpenPrice)
  {
   double Stop=0;
   if(dir==OP_BUY||dir==OP_BUYSTOP||dir==OP_BUYLIMIT) Stop=OpenPrice-SL*_Point;
   if(dir==OP_SELL||dir==OP_SELLSTOP||dir==OP_SELLLIMIT) Stop=OpenPrice+SL*_Point;
   return(NormalizeDouble(Stop,_Digits));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double TakeProfit(int dir,double OpenPrice)
  {
   double Take=0;
   if(dir==OP_BUY||dir==OP_BUYSTOP||dir==OP_BUYLIMIT) Take=OpenPrice+(OpenPrice-StopLoss(OP_BUY,OpenPrice))*(TPProc/100);
   if(dir==OP_SELL||dir==OP_SELLSTOP||dir==OP_SELLLIMIT) Take=OpenPrice-(StopLoss(OP_SELL,OpenPrice)-OpenPrice)*(TPProc/100);
   return(NormalizeDouble(Take,_Digits));
  }
//+------------------------------------------------------------------+
//| Return existing orders counted                                   |
//+------------------------------------------------------------------+
int OrdExist(int direction)
  {
   int OrdCount=0;
   if(OrdersTotal()>0)
     {
      for(int i=OrdersTotal(); i>=0; i--)
        {
         if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) continue;
         if(OrderMagicNumber()!=Magic || OrderSymbol()!=_Symbol) continue;
         if(OrderType()==direction) OrdCount++;
        }
     }
   return (OrdCount);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void TrailingBE()
  {
   int n=0,ticket=0;
   double NewStopBuy=0,NewStopSell=0;
   if(OrdersTotal()>0)
     {
      for(int i=OrdersTotal()-1; i>=0; i--)
        {
         if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) continue;
         if(OrderMagicNumber()!=Magic || OrderSymbol()!=_Symbol) continue;
         if(OrderType()==OP_BUY)
           {
            if(NewStopBuy==0 && UseBE && Bid-BELevel*_Point>OrderOpenPrice() && OrderStopLoss()<OrderOpenPrice() && Bid-BELevel*_Point<Bid-StopLevel*_Point) NewStopBuy=OrderOpenPrice()+BEPlusPips*_Point;
            if(NewStopBuy!=0)
              {
               for(n=1; n<=MathMax(1,RetryAttempts); n++)
                 {
                  ticket=OrderModify(OrderTicket(),OrderOpenPrice(),NewStopBuy,OrderTakeProfit(),0,Green);
                  if(ticket>0)
                    {
                     EAComment("Сработал стандартный безубыток");
                     return;
                    }
                  if(ticket==0 && n<MathMax(1,RetryAttempts))
                    {
                     EAComment("Ошибка стандартного безубытка, пробуем снова!");
                    }
                  if(ticket==0 && n==MathMax(1,RetryAttempts))
                    {
                     EAComment("Ошибка стандартного безубытка!");
                     return;
                    }
                  if(RetryAttemptsPause!=0) sbSleepForMS(RetryAttemptsPause);
                 }
              }
           }
         if(OrderType()==OP_SELL)
           {
            if(NewStopSell==0 && UseBE && Ask+BELevel*_Point<OrderOpenPrice() && OrderStopLoss()>OrderOpenPrice() && Ask+BELevel*_Point>Ask+StopLevel*_Point) NewStopSell=OrderOpenPrice()-BEPlusPips*_Point;
            if(NewStopSell!=0)
              {
               for(n=1; n<=MathMax(1,RetryAttempts); n++)
                 {
                  ticket=OrderModify(OrderTicket(),OrderOpenPrice(),NewStopSell,OrderTakeProfit(),0,Green);
                  if(ticket>0)
                    {
                     EAComment("Сработал стандартный безубыток");
                     return;
                    }
                  if(ticket==0 && n<MathMax(1,RetryAttempts))
                    {
                     EAComment("Ошибка стандартного безубытка, пробуем снова!");
                    }
                  if(ticket==0 && n==MathMax(1,RetryAttempts))
                    {
                     EAComment("Ошибка стандартного безубытка!");
                     return;
                    }
                  if(RetryAttemptsPause!=0) sbSleepForMS(RetryAttemptsPause);
                 }
              }
           }
        }
     }
   return;
  }
//+------------------------------------------------------------------+
//| Открытие ордера                                                  |
//+------------------------------------------------------------------+
void OpenOrder(int direction,double OpenPrice)
  {
   double Lot=0,Stop=0,Take=0;
   int ticket=0,ticket1=0,n=0,i=0;
   color Color;
   Stop=StopLoss(direction,OpenPrice);
   if(direction==OP_BUY)
     {
      Lot=Lots((OpenPrice-Stop)/_Point);
      Color=Blue;
     }
   if(direction==OP_SELL)
     {
      Lot=Lots((Stop-OpenPrice)/_Point);
      Color=Red;
     }
   Take=TakeProfit(direction,OpenPrice);
   for(i=1; i<=MathMax(1,RetryAttempts); i++)
     {

      RefreshRates();
      if(ECNAccount) ticket=OrderSend(_Symbol,direction,Lot,OpenPrice,Slippage,0,0,ExpertName+" "+IntegerToString(Magic)+" Спред:"+(Ask-Bid)/_Point,Magic,0,Color);
      if(!ECNAccount) ticket=OrderSend(_Symbol,direction,Lot,OpenPrice,Slippage,Stop,Take,ExpertName+" "+IntegerToString(Magic)+" Спред:"+(Ask-Bid)/_Point,Magic,0,Color);
      if(ticket>0)
        {
         if(ECNAccount)
           {
            for(n=1; n<=MathMax(1,RetryAttempts); n++)
              {
               RefreshRates();
               ticket1=OrderModify(ticket,OrderOpenPrice(),Stop,Take,0,Green);
               if(ticket1>0)
                 {
                  EAComment("Успешно выставили ТП и СЛ для ордера!");
                  return;
                 }
               if(ticket1==0 && n<MathMax(1,RetryAttempts))
                 {
                  EAComment("ТП и СЛ для ордера не выставлен, пробуем снова!");
                 }
               if(ticket1==0 && n==MathMax(1,RetryAttempts))
                 {
                  EAComment("ТП и СЛ для ордера не выставлены!");
                  return;
                 }
               if(RetryAttemptsPause!=0) sbSleepForMS(RetryAttemptsPause);
              }
           }
         return;
        }
      if(ticket==0 && n<MathMax(1,RetryAttempts))
        {
         EAComment("Ордер не выставлен, пробуем снова!");
        }
      if(ticket==0 && n==MathMax(1,RetryAttempts))
        {
         EAComment("Ордер не выставлен!");
         return;
        }
      if(RetryAttemptsPause!=0) sbSleepForMS(RetryAttemptsPause);
     }
   return;
  }
//+------------------------------------------------------------------+
//| Пауза между попытками                                            |
//+------------------------------------------------------------------+
void sbSleepForMS(int pviSleepForMS)
  {
//This is a Sleep() function designed to work on either LIVE mode or BACKTEST mode.
// The built-in Sleep() function is skipped by MQL4 during Backtesting, thus another
// way to simulate the Sleep() function is required. We will use a while loop for it.

   if(!IsTesting())
      Sleep(pviSleepForMS);

   else
     {
      //This section uses a while loop to simulate Sleep() during Backtest.
      uint viSleepUntilTick=GetTickCount()+pviSleepForMS;
      while(GetTickCount()<viSleepUntilTick)
        {
         //Do absolutely nothing. Just loop until the desired tick is reached.
        }

     }
  }
//+------------------------------------------------------------------+
//| Закрывает все ордера                                             |
//+------------------------------------------------------------------+
bool CloseAllOrders(int dir) // закрытие всех ордеров
  {
   double PriceClose=0;
   int ticket=0,n=0;
   bool rval = false;
   for(int i = OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==_Symbol && OrderMagicNumber()==Magic)
           {
            if(OrderType()==dir)
              {
               if(OrderType() == OP_BUY) PriceClose = Bid;
               if(OrderType() == OP_SELL) PriceClose = Ask;
               for(n=1; n<=MathMax(1,RetryAttempts); n++)
                 {
                  ticket=OrderClose(OrderTicket(),OrderLots(),PriceClose,Slippage,CLR_NONE);
                  if(ticket>0)
                    {
                     EAComment("Успешно закрыли ордер");
                     break;
                    }
                  if(ticket==0 && n<MathMax(1,RetryAttempts))
                    {
                     EAComment("Не удалось закрыть ордер, пробуем снова!");
                    }
                  if(ticket==0 && n==MathMax(1,RetryAttempts))
                    {
                     EAComment("Не удалось закрыть ордер!");
                     break;
                    }
                  if(RetryAttemptsPause!=0) sbSleepForMS(RetryAttemptsPause);
                 }
              }
           }
        }
     }
   return(true);
  }
//+---------------------------------------------------------------------------------------------------+
void informer()
  {
   string today;
   string todayMonth=Month()<10 ? "0"+IntegerToString(Month()) : IntegerToString(Month());
   string todayDay=Day()<10 ? "0"+IntegerToString(Day()) : IntegerToString(Day());

   today=todayDay+"."+todayMonth+"."+Year();

   if(!OrdExist(OP_BUY) && !OrdExist(OP_SELL))
     {

      string month;
      string day;
      string dealType;

      int year= Year();
      int now = DayOfYear();

      int curr = AllDeals[0];
      dealType = "Buy";
      day=DealsBuy[0][1]<10 ? "0"+IntegerToString(DealsBuy[0][1]) : DealsBuy[0][1];
      month=DealsBuy[0][0]<10 ? "0"+IntegerToString(DealsBuy[0][0]) : DealsBuy[0][0];

      for(int i=0;i<40;i++)
        {
         if(AllDeals[i]!=-1 && AllDeals[i]+MaxDayEnterLag>=now)
            if(MathAbs(now-AllDeals[i])<=MathAbs(now-curr) || curr<now)
              {
               curr=AllDeals[i];
               //Print(curr);
               if(i>=0 && i<=19)
                 {
                  dealType="Buy";
                  day=DealsBuy[i][1]<10 ? "0"+IntegerToString(DealsBuy[i][1]) : DealsBuy[i][1];
                  month=DealsBuy[i][0]<10 ? "0"+IntegerToString(DealsBuy[i][0]) : DealsBuy[i][0];

                    } else {

                  dealType="Sell";
                  day=DealsSell[i-20][1]<10 ? "0"+IntegerToString(DealsSell[i-20][1]) : DealsSell[i-20][1];
                  month=DealsSell[i-20][0]<10 ? "0"+IntegerToString(DealsSell[i-20][0]) : DealsSell[i-20][0];

                 }

              }

        }

      //Print("Сейчас "+now+" Открытие "+curr);
      // значит открытие в следующем году
      if(curr<now)
        {

         int nextYearBuy=TimeDayOfYear(StrToTime(Year()+"."+DealsBuy[i][0]+"."+DealsBuy[i][1]));
         int nextYearSell=TimeDayOfYear(StrToTime(Year()+"."+DealsSell[i][0]+"."+DealsSell[i][1]));
         year++;

         if(nextYearBuy<nextYearSell)
           {
            dealType="Buy";
            day=DealsBuy[0][1]<10 ? "0"+IntegerToString(DealsBuy[0][1]) : DealsBuy[0][1];
            month=DealsBuy[0][0]<10 ? "0"+IntegerToString(DealsBuy[0][0]) : DealsBuy[0][0];
              }else{
            dealType="Sell";
            day=DealsSell[0][1]<10 ? "0"+IntegerToString(DealsSell[0][1]) : DealsSell[0][1];
            month=DealsSell[0][0]<10 ? "0"+IntegerToString(DealsSell[0][0]) : DealsSell[0][0];
           }

        }

      if(dealType=="Buy")
         Comment("Текущая дата: "+today+"\n",
                 "Нет открытых ордеров\n"+
                 "Ордер на покупку должен открыться ",day,".",month,".",year);

      if(dealType=="Sell")
         Comment("Текущая дата: "+today+"\n",
                 "Нет открытых ордеров\n"+
                 "Ордер на продажу должен открыться ",day,".",month,".",year);

     }

   if(OrdExist(OP_BUY))
     {

      for(int i3=OrdersTotal(); i3>=0; i3--)
        {
         if(!OrderSelect(i3,SELECT_BY_POS,MODE_TRADES)) continue;
         if(OrderMagicNumber()==Magic || OrderSymbol()==_Symbol)
           {

            int buyDayOpened=TimeDay(OrderOpenTime());
            int buyMonthOpened=TimeMonth(OrderOpenTime());

            string dayCloseBuy;
            string monthCloseBuy;

            for(int i1=0;i1<20;i1++)
              {
               // пропускаем не заполненные значения
               if(DealsBuy[i1][0]==0 || DealsBuy[i1][1]==0)
                  continue;

               if(buyDayOpened>=DealsBuy[i1][1] && buyDayOpened<=DealsBuy[i1][1]+MaxDayExitLag && DealsBuy[i1][0]==buyMonthOpened)
                 {
                  dayCloseBuy=DealsBuy[i1][3]<10 ? "0"+IntegerToString(DealsBuy[i1][3]) : DealsBuy[i1][3];
                  monthCloseBuy=DealsBuy[i1][2]<10 ? "0"+IntegerToString(DealsBuy[i1][2]) : DealsBuy[i1][2];
                 }

              }

            Comment("Текущий день: ",today,"\n",
                    "Открыт ордер на покупку\n",
                    "Ордер должен закрыться ",dayCloseBuy,".",monthCloseBuy,".",Year());

           }
        }

     }

   if(OrdExist(OP_SELL))
     {
      for(int i4=OrdersTotal(); i4>=0; i4--)
        {
         if(!OrderSelect(i4,SELECT_BY_POS,MODE_TRADES)) continue;
         if(OrderMagicNumber()==Magic || OrderSymbol()==_Symbol)
           {

            int sellDayOpened=TimeDay(OrderOpenTime());
            int sellMonthOpened=TimeMonth(OrderOpenTime());

            string dayCloseSell;
            string monthCloseSell;

            for(int i2=0;i2<20;i2++)
              {
               // пропускаем не заполненные значения
               if(DealsSell[i2][0]==0 || DealsSell[i2][1]==0)
                  continue;

               if(sellDayOpened>=DealsSell[i2][1] && sellDayOpened<=DealsSell[i2][1]+MaxDayExitLag && DealsSell[i2][0]==sellMonthOpened)
                 {
                  dayCloseSell=DealsSell[i2][3]<10 ? "0"+IntegerToString(DealsSell[i2][3]) : DealsSell[i2][3];
                  monthCloseSell=DealsSell[i2][2]<10 ? "0"+IntegerToString(DealsSell[i2][2]) : DealsSell[i2][2];
                 }

              }

            Comment("Текущий день: ",today,"\n",
                    "Открыт ордер на продажу\n",
                    "Ордер должен закрыться ",dayCloseSell,".",monthCloseSell,".",Year());

           }
        }

     }

  }
//+------------------------------------------------------------------+

void InitDeals()
  {
   DealsBuy[0][0]=bMonthOpen1;
   DealsBuy[0][1]=bDayOpen1;
   DealsBuy[0][2]=bMonthClose1;
   DealsBuy[0][3]=bDayClose1;


   DealsBuy[1][0]=bMonthOpen2;
   DealsBuy[1][1]=bDayOpen2;
   DealsBuy[1][2]=bMonthClose2;
   DealsBuy[1][3]=bDayClose2;


   DealsBuy[2][0]=bMonthOpen3;
   DealsBuy[2][1]=bDayOpen3;
   DealsBuy[2][2]=bMonthClose3;
   DealsBuy[2][3]=bDayClose3;


   DealsBuy[3][0]=bMonthOpen4;
   DealsBuy[3][1]=bDayOpen4;
   DealsBuy[3][2]=bMonthClose4;
   DealsBuy[3][3]=bDayClose4;

   DealsBuy[4][0]=bMonthOpen5;
   DealsBuy[4][1]=bDayOpen5;
   DealsBuy[4][2]=bMonthClose5;
   DealsBuy[4][3]=bDayClose5;

   DealsBuy[5][0]=bMonthOpen6;
   DealsBuy[5][1]=bDayOpen6;
   DealsBuy[5][2]=bMonthClose6;
   DealsBuy[5][3]=bDayClose6;

   DealsBuy[6][0]=bMonthOpen7;
   DealsBuy[6][1]=bDayOpen7;
   DealsBuy[6][2]=bMonthClose7;
   DealsBuy[6][3]=bDayClose7;

   DealsBuy[7][0]=bMonthOpen8;
   DealsBuy[7][1]=bDayOpen8;
   DealsBuy[7][2]=bMonthClose8;
   DealsBuy[7][3]=bDayClose8;

   DealsBuy[8][0]=bMonthOpen9;
   DealsBuy[8][1]=bDayOpen9;
   DealsBuy[8][2]=bMonthClose9;
   DealsBuy[8][3]=bDayClose9;

   DealsBuy[9][0]=bMonthOpen10;
   DealsBuy[9][1]=bDayOpen10;
   DealsBuy[9][2]=bMonthClose10;
   DealsBuy[9][3]=bDayClose10;

   DealsBuy[10][0]=bMonthOpen11;
   DealsBuy[10][1]=bDayOpen11;
   DealsBuy[10][2]=bMonthClose11;
   DealsBuy[10][3]=bDayClose11;

   DealsBuy[11][0]=bMonthOpen12;
   DealsBuy[11][1]=bDayOpen12;
   DealsBuy[11][2]=bMonthClose12;
   DealsBuy[11][3]=bDayClose12;

   DealsBuy[12][0]=bMonthOpen13;
   DealsBuy[12][1]=bDayOpen13;
   DealsBuy[12][2]=bMonthClose13;
   DealsBuy[12][3]=bDayClose13;

   DealsBuy[13][0]=bMonthOpen14;
   DealsBuy[13][1]=bDayOpen14;
   DealsBuy[13][2]=bMonthClose14;
   DealsBuy[13][3]=bDayClose14;

   DealsBuy[14][0]=bMonthOpen15;
   DealsBuy[14][1]=bDayOpen15;
   DealsBuy[14][2]=bMonthClose15;
   DealsBuy[14][3]=bDayClose15;

   DealsBuy[15][0]=bMonthOpen16;
   DealsBuy[15][1]=bDayOpen16;
   DealsBuy[15][2]=bMonthClose16;
   DealsBuy[15][3]=bDayClose16;

   DealsBuy[16][0]=bMonthOpen17;
   DealsBuy[16][1]=bDayOpen17;
   DealsBuy[16][2]=bMonthClose17;
   DealsBuy[16][3]=bDayClose17;

   DealsBuy[17][0]=bMonthOpen18;
   DealsBuy[17][1]=bDayOpen18;
   DealsBuy[17][2]=bMonthClose18;
   DealsBuy[17][3]=bDayClose18;

   DealsBuy[18][0]=bMonthOpen19;
   DealsBuy[18][1]=bDayOpen19;
   DealsBuy[18][2]=bMonthClose19;
   DealsBuy[18][3]=bDayClose19;

   DealsBuy[19][0]=bMonthOpen20;
   DealsBuy[19][1]=bDayOpen20;
   DealsBuy[19][2]=bMonthClose20;
   DealsBuy[19][3]=bDayClose20;

   DealsSell[0][0]=sMonthOpen1;
   DealsSell[0][1]=sDayOpen1;
   DealsSell[0][2]=sMonthClose1;
   DealsSell[0][3]=sDayClose1;

   DealsSell[1][0]=sMonthOpen2;
   DealsSell[1][1]=sDayOpen2;
   DealsSell[1][2]=sMonthClose2;
   DealsSell[1][3]=sDayClose2;

   DealsSell[2][0]=sMonthOpen3;
   DealsSell[2][1]=sDayOpen3;
   DealsSell[2][2]=sMonthClose3;
   DealsSell[2][3]=sDayClose3;

   DealsSell[3][0]=sMonthOpen4;
   DealsSell[3][1]=sDayOpen4;
   DealsSell[3][2]=sMonthClose4;
   DealsSell[3][3]=sDayClose4;

   DealsSell[4][0]=sMonthOpen5;
   DealsSell[4][1]=sDayOpen5;
   DealsSell[4][2]=sMonthClose5;
   DealsSell[4][3]=sDayClose5;

   DealsSell[5][0]=sMonthOpen6;
   DealsSell[5][1]=sDayOpen6;
   DealsSell[5][2]=sMonthClose6;
   DealsSell[5][3]=sDayClose6;

   DealsSell[6][0]=sMonthOpen7;
   DealsSell[6][1]=sDayOpen7;
   DealsSell[6][2]=sMonthClose7;
   DealsSell[6][3]=sDayClose7;

   DealsSell[7][0]=sMonthOpen8;
   DealsSell[7][1]=sDayOpen8;
   DealsSell[7][2]=sMonthClose8;
   DealsSell[7][3]=sDayClose8;

   DealsSell[8][0]=sMonthOpen9;
   DealsSell[8][1]=sDayOpen9;
   DealsSell[8][2]=sMonthClose9;
   DealsSell[8][3]=sDayClose9;

   DealsSell[9][0]=sMonthOpen10;
   DealsSell[9][1]=sDayOpen10;
   DealsSell[9][2]=sMonthClose10;
   DealsSell[9][3]=sDayClose10;

   DealsSell[10][0]=sMonthOpen11;
   DealsSell[10][1]=sDayOpen11;
   DealsSell[10][2]=sMonthClose11;
   DealsSell[10][3]=sDayClose11;

   DealsSell[11][0]=sMonthOpen12;
   DealsSell[11][1]=sDayOpen12;
   DealsSell[11][2]=sMonthClose12;
   DealsSell[11][3]=sDayClose12;

   DealsSell[12][0]=sMonthOpen13;
   DealsSell[12][1]=sDayOpen13;
   DealsSell[12][2]=sMonthClose13;
   DealsSell[12][3]=sDayClose13;

   DealsSell[13][0]=sMonthOpen14;
   DealsSell[13][1]=sDayOpen14;
   DealsSell[13][2]=sMonthClose14;
   DealsSell[13][3]=sDayClose14;

   DealsSell[14][0]=sMonthOpen15;
   DealsSell[14][1]=sDayOpen15;
   DealsSell[14][2]=sMonthClose15;
   DealsSell[14][3]=sDayClose15;

   DealsSell[15][0]=sMonthOpen16;
   DealsSell[15][1]=sDayOpen16;
   DealsSell[15][2]=sMonthClose16;
   DealsSell[15][3]=sDayClose16;

   DealsSell[16][0]=sMonthOpen17;
   DealsSell[16][1]=sDayOpen17;
   DealsSell[16][2]=sMonthClose17;
   DealsSell[16][3]=sDayClose17;

   DealsSell[17][0]=sMonthOpen18;
   DealsSell[17][1]=sDayOpen18;
   DealsSell[17][2]=sMonthClose18;
   DealsSell[17][3]=sDayClose18;

   DealsSell[18][0]=sMonthOpen19;
   DealsSell[18][1]=sDayOpen19;
   DealsSell[18][2]=sMonthClose19;
   DealsSell[18][3]=sDayClose19;

   DealsSell[19][0]=sMonthOpen20;
   DealsSell[19][1]=sDayOpen20;
   DealsSell[19][2]=sMonthClose20;
   DealsSell[19][3]=sDayClose20;

   for(int i=0;i<20;i++)
     {
      if(DealsBuy[i][0]==0 || DealsBuy[i][1]==0)
        {
         AllDeals[i]=-1;
           }else {
         AllDeals[i]=TimeDayOfYear(StrToTime(Year()+"."+DealsBuy[i][0]+"."+DealsBuy[i][1]));
        }
     }

   for(int i2=0;i2<20;i2++)
     {
      if(DealsSell[i2][0]==0 || DealsSell[i2][1]==0)
        {
         AllDeals[i2+20]=-1;
           } else {
         AllDeals[i2+20]=TimeDayOfYear(StrToTime(Year()+"."+DealsSell[i2][0]+"."+DealsSell[i2][1]));
        }

     }

  }
//+------------------------------------------------------------------+

void fArrowsRest()
{
   int      i;
   string   cArrowOpenName;
   string   cArrowCloseName;
   string   cTrendLineName;
   for( i = 0; i <= OrdersHistoryTotal(); i++ )
      if( OrderSelect( i, SELECT_BY_POS, MODE_HISTORY ) )
         if( OrderSymbol() == Symbol() && OrderMagicNumber()==Magic )
         {
            cArrowOpenName = "#" + DoubleToStr( OrderTicket(), 0 ) + " " + fIfThenStr( OrderType() == OP_BUY, "buy", "sell" ) + " " + 
               DoubleToStr( OrderLots(), 2 ) + " " + Symbol() + " at " + DoubleToStr( OrderOpenPrice(), MarketInfo( Symbol(), MODE_DIGITS ) );
            cArrowCloseName = cArrowOpenName + " close at " + DoubleToStr(  OrderClosePrice(), MarketInfo( Symbol(), MODE_DIGITS ) );
            if( OrderType() == OP_BUY )  fArrowPaint( cArrowOpenName, OrderOpenTime(), OrderOpenPrice(), 1, Blue );
            if( OrderType() == OP_SELL ) fArrowPaint( cArrowOpenName, OrderOpenTime(), OrderOpenPrice(), 2, Red  );
            fArrowPaint( cArrowCloseName, OrderCloseTime(), OrderClosePrice(), 3, Green );
            cTrendLineName = "#" + DoubleToStr( OrderTicket(), 0 ) + " " + DoubleToStr( OrderOpenPrice(), MarketInfo( Symbol(), MODE_DIGITS ) ) + " -> " + DoubleToStr( OrderClosePrice(), MarketInfo( Symbol(), MODE_DIGITS ) );
            if( ObjectFind( cTrendLineName ) == -1 )
            {
               ObjectCreate( cTrendLineName, OBJ_TREND, 0, OrderOpenTime(), OrderOpenPrice(), OrderCloseTime(), OrderClosePrice() );
               ObjectSet( cTrendLineName, OBJPROP_STYLE, STYLE_DOT );
               ObjectSet( cTrendLineName, OBJPROP_WIDTH, 1 );
               ObjectSet( cTrendLineName, OBJPROP_COLOR, fIfThenInt( OrderType() == OP_BUY, Blue, Red ) );
               ObjectSet( cTrendLineName, OBJPROP_RAY, 0 );
            }
         }
   for( i = 0; i <= OrdersTotal(); i++ )
      if( OrderSelect( i, SELECT_BY_POS, MODE_TRADES ) )
         if( OrderSymbol() == Symbol() && OrderMagicNumber()==Magic)
         {
            cArrowOpenName = "#" + DoubleToStr( OrderTicket(), 0 ) + " " + fIfThenStr( OrderType() == OP_BUY, "buy", "sell" ) + " " + 
               DoubleToStr( OrderLots(), 2 ) + " " + Symbol() + " at " + DoubleToStr( OrderOpenPrice(), MarketInfo( Symbol(), MODE_DIGITS ) );
            if( OrderType() == OP_BUY )  fArrowPaint( cArrowOpenName, OrderOpenTime(), OrderOpenPrice(), 1, Blue );
            if( OrderType() == OP_SELL ) fArrowPaint( cArrowOpenName, OrderOpenTime(), OrderOpenPrice(), 2, Red  );
         }
}

void fArrowPaint( string cArrowName, datetime dTime, double nPrice, int nArrowCode, int nArrowColor )
{
   if( ObjectFind( cArrowName ) == -1 ) 
   {
      ObjectCreate( cArrowName, OBJ_ARROW, 0, dTime, nPrice );
      ObjectSet( cArrowName, OBJPROP_ARROWCODE, nArrowCode );
      ObjectSet( cArrowName, OBJPROP_COLOR, nArrowColor );
   }   
}

// +--- Вовращает строку cStr1 если условие lIf == true, иначе возвращает строку cStr2 -------------------------------------------------------------------------------+
string fIfThenStr( bool lIf, string cStr1, string cStr2 )
{
   if( lIf ) return( cStr1 ); else return( cStr2 );
}

// +--- Вовращает целое число nInt1, если условие lIf == true, иначе возвращает целое число nInt2 --------------------------------------------------------------------+
int fIfThenInt( bool lIf, int nInt1, int nInt2 )
{
   if( lIf ) return( nInt1 ); else return( nInt2 );
}

double MMCoeff()
  {
   if(OrdersHistoryTotal()==0) return(1);
   double Pips[];
   int OrdersCount=0,i=0,j=1,k=0;
   for(i=OrdersHistoryTotal()-1; i>=0; i--)
     {
      if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)) continue;
      if(OrderMagicNumber()!=Magic || OrderSymbol()!=Symbol()) continue;
      if(OrderType()==OP_BUY || OrderType()==OP_SELL)OrdersCount++;
     }
   ArrayResize(Pips,OrdersCount+1);
   for(i=0; i<=OrdersHistoryTotal()-1; i++)
     {
      if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)) continue;
      if(OrderMagicNumber()!=Magic || OrderSymbol()!=Symbol()) continue;
      if(OrderType()==OP_BUY)
        {
         //Print(__FUNCTION__ , ": OP_BUY j = ", j, ", Pips[j] = ",Pips[j]);
         Pips[j]=Pips[j-1]+(OrderClosePrice()-OrderOpenPrice())/_Point;
        }
      if(OrderType()==OP_SELL)
        {
         //Print(__FUNCTION__ , ": OP_SELL j = ", j, ", Pips[j] = ",Pips[j], ", ArraySize ", ArraySize(Pips));
         Pips[j]=Pips[j-1]+(OrderOpenPrice()-OrderClosePrice())/_Point;
        }
      j++;
     }

   double BBUp=iBandsOnArray(Pips,0,MAMMPer,MADev,0,MODE_UPPER,0);
   double BBDn=iBandsOnArray(Pips,0,MAMMPer,MADev,0,MODE_LOWER,0);
   double BBCt=iBandsOnArray(Pips,0,MAMMPer,MADev,0,MODE_MAIN,0);
   double CCI0=iCCIOnArray(Pips,0,CCIMMPer,0);
   double CCI1=iCCIOnArray(Pips,0,CCIMMPer,1);
   if(UseMABalanceCorr)
     {
      if(Pips[OrdersCount-1]<BBCt && Pips[OrdersCount-1]>BBDn)
        {
         if(UseOSCBalanceCorr&&CCI0>CCI1&&CCI0<-CCIMMLevel) return(Coeff2);
         if((UseOSCBalanceCorr&&CCI0<CCI1)||!UseOSCBalanceCorr) return(Coeff5);
        }
      if(Pips[OrdersCount-1]<BBDn)
        {
         if(UseOSCBalanceCorr&&CCI0>CCI1&&CCI0<-CCIMMLevel) return(Coeff1);
         if((UseOSCBalanceCorr&&CCI0<CCI1)||!UseOSCBalanceCorr) return(Coeff6);
        }
      if(Pips[OrdersCount-1]>BBCt && Pips[OrdersCount-1]<BBUp)
        {
         if(UseOSCBalanceCorr&&CCI0>CCI1&&CCI0<-CCIMMLevel) return(Coeff3);
         if((UseOSCBalanceCorr&&CCI0<CCI1)||!UseOSCBalanceCorr) return(Coeff4);
        }
      if(Pips[OrdersCount-1]>BBUp)
        {
         if(UseOSCBalanceCorr&&CCI0>CCI1&&CCI0<-CCIMMLevel) return(Coeff4);
         if((UseOSCBalanceCorr&&CCI0<CCI1)||!UseOSCBalanceCorr) return(Coeff5);
        }
     }
   if(!UseMABalanceCorr && UseOSCBalanceCorr)
     {
      if(CCI0<-CCIMMLevel&&CCI0>CCI1) return(Coeff1);
      if(CCI0<-CCIMMLevel&&CCI0<CCI1) return(Coeff6);
      if(CCI0>-CCIMMLevel&&CCI0<CCI1) return(Coeff3);
      if(CCI0>-CCIMMLevel&&CCI0>CCI1) return(Coeff4);
     }
   return(1);
  }