//+------------------------------------------------------------------+
//|                                               ZigZaHod v1.0.mq4  |
//|                                                                  |                             
//|                                                     Coders ZEVs  |
//|                           https://www.mql5.com/ru/users/fortorg  |
//+------------------------------------------------------------------+
#property copyright "Coders ZEVs"
#property link      "http://"
#include <stdlib.mqh>
int     BarsFr=5;
int     PervFr=3;
int     PropCandlFr=0;
extern bool      SigFractal=true;
//  extern bool     SigCandle=false;
extern int       ABminRazmer=100;      //  минимальный размер AB
extern int       Otstup=15;            //  отступ пунктов  отл.( спред)
extern double       OtstupProc=0.1;    // отступ отл. от AB (0.1 = 10 %)
extern int       MaxOrder=10;          //  мах. кол-во ордеров (не больше 30, огр. в массиве)
int       MaxOrdersetka   = 1;        //кол-во ордеров сетки
int       delta       = 25;           //расстояние от текущей цены
extern double    KoefProfit=1.5;       //  Коефициент профита
extern double    DelKorStopOrder=0.6;  //  глубина коррекции при которой убирать отл.
// extern bool      TudySydy=false;
extern bool      OtmerennyiHod=true;   //  отмеренный ход.
extern bool      OdnaStor=true;        //  Торговля в одну сторону.
bool      ObeStor=false;
double temp;// ABBA
extern bool      SignalDelOldOtl=false;     //  удаляет предыдущую отложку своего направления при сигнале
extern bool      SignalDelOldOtlAll=false;  //  удаляе ВСЕ старые отложки при сигнале
bool    DelBS=false;
bool    DelSS=false;
//extern bool      DelBStopOrder=true;
extern bool      StopLos=false;           // выставляет SL за В
int OpBar=0;
int OtkatBar=0;
double Hod=0;
double OtkatCena=0;
double MA,MB,MRazmer,MTime;

//----
int  TfFr,hi,lo;
double h1,h2,h3,h4,l1,l2,l3,l4;
int    hk1,hk2,hk3,hk4,lk1,lk2,lk3,lk4,kstart;
double hf,lf;
bool  NewOrder=true;
double A,B,C,D,Eh,El,AB,E,F,Up,Dn;
int k=1,i=0,Ak,Bk=0,Ck,Dk,Ek,Fk,Upk,Dnk;
int SigTfFr=0;
//----
extern string Трал="-=-=-";
//extern   int TipTrala=1;
extern   bool     bTrlinloss= false;  // следует ли тралить на участке лоссов (между курсом стоплосса и открытия)
extern bool      SLSignal=false;      //  выставляет SL на уровне нового сигнала противоположного направления (если "одна сторона" то не работает)
extern   int      iTmfrm=240;              // период графика, на котором определяются фракталы или тени (1, 5, 15, 30, 60, 240, 1440, 10080, 43200)
extern   int      iIndent=50;         // отступ от тени бара, на котором размещается стоплосс
extern   int   Frktl_bars = 5;    // кол-во баров во фрактале
extern   int   Frktl_kol = 0;     // кол-во фракталов по которым тралить
extern   int   Bars_kol=19;   // кол-во баров, по теням которых следует тралить 
//--------
extern double TargetLoss    = 99999;                // Целевой убыток
extern double TargetProfit  = 99999;                // Целевая прибыль
int    NumberOfTry= 5;                 // Количество попыток
color clCloseBuy  = Blue;              // Цвет значка закрытия покупки
color clCloseSell = Red;               // Цвет значка закрытия продажи
color clDelete    = Yellow;            // Цвет значка удаления ордера

bool   UseSound      = False;             // Использовать звуковой сигнал
string SoundSuccess  = "ok.wav";          // Звук успеха
string SoundError    = "timeout.wav";     // Звук ошибки
//-------
int iTicket;
int H_fractal=0,L_fractal=0;
int hTralFr,lTralFr;
int Tmfrm;
//---
double SelSL,BuySL;
double Target,Razmer;
int BBars=0;
bool  New_Bar=true;
string   ExpertComment="test";
int      NumberOfTries=5;
double BStp=0,SStp=0,BSsl=0,SSsl=0,BSotl=0,SSotl=0;
double Mas_Ord_Tek[31][8];  // Обьявляем массив текущих ордеров
                            // 1й индекс = порядковый номер ордера в этом массиве
// [0][0]   Кол-во открытых ордеров
// [][1] курс откр. ордера   (абсолютное знач. курса)
// [][2] StopLoss ордера     (абсолютное знач. курса)
// [][3] TakeProfit ордера   (абсолютное знач. курса)
// [][4] номер ордера         ticket   
// [][5] колич. лотов ордера (абсолютное знач. курса)
// [][6] тип ордера 0=B,1=S,2=BL,3=SL,4=BS,5=SS
// [][7] Магическое число ордера  MagicNumber
double Massiv[31][10]; // Обьявляем массив -= Massiv =- Основной массив
                       // 1й индекс = порядковый номер ордера в этом массиве
// [0][1]  MagicNumber         !!! самый Новый магик  !!!
// [0][2]  MinMagicNumber  откр. ордеров(из блока сравнения ордеров)
// [0][3]  ближайшая свободная строка
// [0][5] счетчик сохранений
//  Massiv[][1]; // Цена A  
//  Massiv[][2];  // Цена B
//  Massiv[][3]; // Размер АB
//  Massiv[][5];  // Время  АB  
//  Massiv[][6];  // таймфрейм  TfFr    

//--------------------------------------------------------------------
extern bool      Commentariy=true;
// extern bool      DelHistoryMassiv=true;
bool      DelHistoryMassiv=true;
extern bool      SaveMassiv=false;
extern int       MagicNumber=515000000;
double LotB,LotS;
extern double    Lot=0.01;
int Kol_B_S;
extern bool      LotProiz=false;   //  ;-)
double Lots;
extern int       Slippage=10;
bool BuyCondition=false,SellCondition=false;// CloseBuyCondition=false , CloseSellCondition=false;
int Magic;int MN;
bool PauseNews=false;
string Spread;
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int init()
  {
//   Magic=StrToInteger(StringSubstr(DoubleToStr(MagicNumber,0), 0, 3));
//   if (SaveMassiv==false)//Massiv[0][1]=MagicNumber;
//     {
//        Massiv[0][1]=MagicNumber;
//      MN=MagicNumber;
//      if (Massiv[0][1]>MagicNumber) MagicNumber=Massiv[0][1]; // !!! самый Новый магик  !!!
//      if (MagicNumber>MN+9999) MagicNumber= MN; 
//     }
   if(SaveMassiv)
     {
      FilesOpen(); // Читаем Файл в массив -->-Massiv
                   //      MN=MagicNumber;
      //      if (Massiv[0][1]>MagicNumber) MagicNumber=Massiv[0][1]; // !!! самый Новый магик  !!!
      //      if (Massiv[0][1]<MN) {MagicNumber=MN ; Massiv[0][1]=MagicNumber; FilesWrite();}
      //      if (MagicNumber>MN+99999) {MagicNumber= MN;Massiv[0][1]=MagicNumber;FilesWrite();} 
      //      return(0);
     }
//Magic=StrToInteger(StringSubstr(DoubleToStr(MagicNumber,0), 0, 3));
   return(0);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int deinit()
  {
//   Massiv [0][1]=Massiv [0][1]+1;
   if(SaveMassiv)
     {
      //      if (Massiv [0][1]==0)  Massiv [0][1]=MagicNumber;
      //      if (Massiv [0][1]!=MagicNumber)  
      //      Massiv [0][1]=Massiv [0][1]+1;
      FilesWrite(); //  //  Пишем массив Massiv --> в Файл    
     }
   return(0);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int Crossed()
  {
//  -------- Определяем новости ... Если есть то не торгуем.
   int Min_Dist=MarketInfo(Symbol(),MODE_STOPLEVEL); // Мин. дистанция STOPLEVEL
   int Min_Freez=MarketInfo(Symbol(),MODE_FREEZELEVEL); // Мин. дистанция FREEZELEVEL
   if(PauseNews==true &&(Min_Dist>100|| Min_Freez>100)) // проверка новостей
      //  -------- Проверяем новый бар...     
      //    Fun_New_Bar();    // Проверяем новый бар
      //    if (New_Bar==false)   return; // ..то уходим 
      NewOrder=false;
   hi=0;lo=0;A=0;B=0;C=0;D=0;E=0;F=0;Up=0;Dn=0;
   Ak=0;Bk=0;Ck=0;Dk=0;Ek=0;Fk=0;Upk=0;Dnk=0;
//      hk1=0;hk2=0;hk3=0;lk1=0;lk2=0;lk3=0;
   TfFr=0;
//   BarsFr=0;  
   kstart=PropCandlFr;
   hlFractal();  // Находим hl фракталы   

   if(hk1==lk1 && hk1==PervFr) return(0);  // туда-сюда 
   if(SigFractal)
     {
      if((hk1<lk1) && (hk1==PervFr) && (High[1]<High[3] && High[2]<High[3])) // && (hk2>=lk2)) // up
        {
         A=iHigh(Symbol(),TfFr,PervFr); B=l1;C=h2;D=l2;
         Ak=hk1;Bk=lk1;Ck=hk2;Dk=lk2;
         //         hi=iHighest(Symbol(),TfFr, MODE_HIGH, lk2,PropCandlFr);
         //         lo=iLowest(Symbol(),TfFr, MODE_LOW, lk2,PropCandlFr);
         //         if (iHigh(Symbol(),TfFr,hi)>A ||  iLow(Symbol(),TfFr,lo)<B){return(0);}
        }

      if((lk1<hk1) && (lk1==PervFr) && (Low[1]>Low[3] && Low[2]>Low[3]))// && (lk2>=hk2)) //
        {
         A=iLow(Symbol(),TfFr,PervFr);B=h1;C=l2;D=h2;
         Ak=lk1;Bk=hk1;Ck=lk2;Dk=hk2;
         //         lo=iLowest(Symbol(),TfFr, MODE_LOW, hk2,PropCandlFr) ;
         //         hi=iHighest(Symbol(),TfFr, MODE_HIGH, hk2,PropCandlFr) ;
         //         if (iHigh(Symbol(),TfFr,hi)>B || iLow(Symbol(),TfFr,lo)<A){ return(0);}
        }
     }

   AB=(A-B)*100000; // ??? *Point
   Razmer=AB;
   if(Razmer<0) {Razmer=-Razmer;}
   if(Razmer<ABminRazmer)return(0);

   SelSL=0;
   BuySL=0;

   if(A>B)
     {
      if((DelKorStopOrder>0) && ((B+Razmer*DelKorStopOrder*Point)>iLow(Symbol(),0,1)))return(0);
      NewOrder=true; SelSL=A;BuySL=0;
      if(ObeStor) return(5);
      return(1);//BuyCondition  return(1);
     }

   if(A<B)
     {
      if((DelKorStopOrder>0) && ((B-Razmer*DelKorStopOrder*Point)<iHigh(Symbol(),0,1)))return(0);
      NewOrder=true; BuySL=A;SelSL=0;
      if(ObeStor) return(5);
      return(2);//SellCondition  return(2);
     }

   return(0); //elsewhere
  }
//+------------------------------------------------------------------+
int start()
  {
   string st;
//  Magic=StrToInteger(StringSubstr(DoubleToStr(MagicNumber,0), 0, 3));
   if(OtstupProc==10) {OtstupProc=0.1;} // енто для совместимости со старой версией
   if(AccountProfit()<-TargetLoss || AccountProfit()>TargetProfit)
     {
      ClosePosFirstProfit();
      DeleteOrders();
     }
//  MasTekOrder (); // Ищем и заносим в Массив Mas_Ord_Tek все ордера 
//  SravMas();
   int cnt,ticket,total;
   BuyCondition=false; SellCondition=false;// CloseBuyCondition=false , CloseSellCondition=false;
//--- Trading conditions
   Fun_New_Bar();    // Проверяем новый бар
   if(New_Bar)
     { // ..то уходим 
      if(Crossed()==1)
         BuyCondition=true;
      if(Crossed()==2)
         SellCondition=true;
      if(Crossed()==5){SellCondition=true;BuyCondition=true;}
     }
//================================================================
//  Ищем все открытые ордера и Работем с ними... Удаляем отложки и тралим
//================================================================
   Kol_B_S=0;
   DelBS=false;DelSS=false;
   LotB=0; LotS=0;
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
        {
         ticket=OrderTicket();
         iTicket=ticket;
         if((OdnaStor) && (OrderType()==1)) {DelBS=true;}  //  buy 
         if((OdnaStor) && (OrderType()==0)) {DelSS=true;}  //  sell
         if((OrderType()==1) || (OrderType()==0)) {Kol_B_S++;}  //  buy 
         if((OdnaStor)  && (BuyCondition) &&(OrderType()==1)) {BuyCondition=false;}  //  buy 
         if((OdnaStor) &&(SellCondition) &&(OrderType()==0)) {SellCondition=false;}  //  sell
         if(OrderType()==OP_BUY) {LotB=LotB+OrderLots();}
         if(OrderType()==OP_SELL) {LotS=LotS+OrderLots();}

        }
     }
//================================================================
//  Ищем все открытые ордера и Работем с ними... Удаляем отложки и тралим TP 
//       -=-=-=-=-=-=-=   Масив...  ;-)   -=-=-=-=-=-=
//================================================================
// MasTekOrder();   
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      if(OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES))
        {
         ticket=OrderTicket();
         iTicket=ticket;
         for(int h=1;h<=30;h++) //
           {
            if((Massiv[h][4]==ticket)) break; // 
           }
         MA=Massiv[h][1]; // Цена A  
         MB=Massiv[h][2];  // Цена B
         MRazmer=Massiv[h][3]; // Размер АB
         MTime=Massiv[h][5];  // Время  АB         

         if(OrderType()==OP_SELLSTOP && OrderSymbol()==Symbol())
           {
            if(DelSS){CloseOrder(OrderType());}
            if((SignalDelOldOtl) && (SellCondition)) {CloseOrder(OrderType());}
            if((SignalDelOldOtlAll) && ((BuyCondition) || (SellCondition))) {CloseOrder(OrderType());}
            if((DelKorStopOrder>0) && (OtmerennyiHod==false) && ((MB-MRazmer*DelKorStopOrder*Point)<iHigh(Symbol(),0,1))){CloseOrder(OrderType());}
            //         if ((DelBStopOrder) && MB<iHigh(Symbol(),0,1)){CloseOrder (OrderType());}
            if(OtmerennyiHod) MasOtmerHod(ticket);
           }
         if(OrderType()==OP_BUYSTOP && OrderSymbol()==Symbol())
            //     if(OrderType()==OP_BUYSTOP && OrderSymbol()==Symbol() && Magic==StrToInteger(StringSubstr(DoubleToStr(OrderMagicNumber(),0), 0, 3)))
           {
            if(DelBS){CloseOrder(OrderType());}
            if((SignalDelOldOtl) && (BuyCondition)) {CloseOrder(OrderType());}
            if((SignalDelOldOtlAll) && ((BuyCondition) || (SellCondition))) {CloseOrder(OrderType());}
            if((DelKorStopOrder>0) && (OtmerennyiHod==false) && ((MB+MRazmer*DelKorStopOrder*Point)>iLow(Symbol(),0,1))){CloseOrder(OrderType());}
            //         if ((DelBStopOrder)  && MB>iLow(Symbol(),0,1)){CloseOrder (OrderType());}
            if(OtmerennyiHod) MasOtmerHod(ticket);

           }

         if(OrderType()==OP_SELL && OrderSymbol()==Symbol())
           {
            if(OtmerennyiHod) MasOtmerHod(ticket);
            TrailingByZ(iTicket,iTmfrm,Bars_kol,iIndent,bTrlinloss);
           }   // Запускаем TrailingStop       
         if(OrderType()==OP_BUY && OrderSymbol()==Symbol()) //<-- Go to short position
           {
            if(OtmerennyiHod) MasOtmerHod(ticket);
            TrailingByZ(iTicket,iTmfrm,Bars_kol,iIndent,bTrlinloss);
           }   // Запускаем TrailingStop   
        }
     }


//================================================================
// Выставляем отложки
//================================================================
   total=OrdersTotal();
   SLTP(); // Вызываем подпрограмму расчета sl, tp,... открываемых ордеров
           //   if ((ObeStor==true)&&((BuyCondition==true)||(SellCondition==true))){BuyCondition=true;SellCondition=true;}
   Lots=Lot;
   if(LotProiz)
     {
      Lots=(Lot*(Kol_B_S+1)*2);  // пипец... я сам в шоке  ;-)
      if(Lots==0) Lots=Lot;
     }

   if(total<MaxOrder)
     {
      if((BuyCondition))//<-- BUY condition
        {
         ticket=OpenOrder(OP_BUYSTOP); //<-- Open BUYSTOP order
         CheckError(ticket,"BUYSTOP"); // return(0);
        }
      if((SellCondition)) //<-- SELL condition
        {
         ticket=OpenOrder(OP_SELLSTOP); //<-- Open SELLSTOP order
         CheckError(ticket,"SELLSTOP"); // return(0);
        }
     }
   BuyCondition=false; SellCondition=false;// CloseBuyCondition=false ; CloseSellCondition=false;
                                           //Spread=MarketInfo(Symbol(),MODE_SPREAD); ExpertComment=MarketInfo(Symbol(),MODE_SPREAD);
//MasTekOrder (); // Ищем и заносим в Массив Mas_Ord_Tek все ордера 
//SravMas();

   if(Commentariy==true)
     {
      Spread=MarketInfo(Symbol(),MODE_SPREAD); ExpertComment=MarketInfo(Symbol(),MODE_SPREAD);
      st="Целевой убыток="+DoubleToStr(-TargetLoss,2)+" "+AccountCurrency()+"  Текущ";
      if(AccountProfit()<0) st=st+"ий убыток=";
      else st=st+"ая прибыль=";
      st=st+DoubleToStr(AccountProfit(),2)+" "+AccountCurrency()+"  Целевая прибыль="+DoubleToStr(TargetProfit,2)+" "+AccountCurrency();
      MasTekOrder(); // Ищем и заносим в Массив Mas_Ord_Tek все ордера 
      SravMas();
      Comment("",TimeToStr(Time[0],TIME_MINUTES),
              "\n ",st,
              "\n Кол-во ордеров= ",Mas_Ord_Tek[0][0],",Пусто= ",Massiv[0][3],
              //       "\n ticket= ",Mas_Ord_Tek[1][4],", Тип ордера= ",Mas_Ord_Tek[1][6],", magik= ",Mas_Ord_Tek[1][7],
              //       "\n ticket= ",Mas_Ord_Tek[2][4],", Тип ордера= ",Mas_Ord_Tek[2][6],", magik= ",Mas_Ord_Tek[2][7],
              //       "\n ticket= ",Mas_Ord_Tek[3][4],", Тип ордера= ",Mas_Ord_Tek[3][6],", magik= ",Mas_Ord_Tek[3][7],
              "\n ticketm= ",Massiv[1][4],", Тип ордера= ",Massiv[1][6],", magik= ",Massiv[1][7],", A= ",Massiv[1][1],", B= ",Massiv[1][2],", Razmer= ",Massiv[1][3],", Time= ",Massiv[1][5],
              "\n ticketm= ",Massiv[2][4],", Тип ордера= ",Massiv[2][6],", magik= ",Massiv[2][7],", A= ",Massiv[2][1],", B= ",Massiv[2][2],", Razmer= ",Massiv[2][3],", Time= ",Massiv[2][5],
              //       "\n ticketm= ",Massiv[3][4],", Тип ордера= ",Massiv[3][6],", magik= ",Massiv[3][7],", A= ",Massiv[3][1],", B= ",Massiv[3][2],", Razmer= ",Massiv[3][3],", Time= ",Massiv[3][5],
              //       "\n ticketm= ",Massiv[4][4],", Тип ордера= ",Massiv[4][6],", magik= ",Massiv[4][7],", A= ",Massiv[4][1],", B= ",Massiv[4][2],", Razmer= ",Massiv[4][3],", Time= ",Massiv[4][5],
              //       "\n ticketm= ",Massiv[5][4],", Тип ордера= ",Massiv[5][6],", magik= ",Massiv[5][7],
              //       "\n ticketm= ",Massiv[6][4],", Тип ордера= ",Massiv[6][6],", magik= ",Massiv[6][7],
              //       "\n ticketm= ",Massiv[7][4],", Тип ордера= ",Massiv[7][6],", magik= ",Massiv[7][7],
              //       "\n MagicNumberRead= ",Massiv [0][1],", MinMagic= ",Massiv [0][2],", MagicNumber= ",MagicNumber,
              "\n Spread ",Spread,", MagicNumber= ",MagicNumber,"  Сохраненно= ",Massiv[0][5],
              "\n A= ",Ak,"   ",A,
              "\n B= ",Bk,"   ",B,
              "\n AB= ",AB);
     }
//Massiv[0][1]=MagicNumber;
   if(AccountProfit()<-TargetLoss || AccountProfit()>TargetProfit)
     {
      ClosePosFirstProfit();
      DeleteOrders();
     }
   return(0);
  }
//+------------------------------------------------------------------+
// Конец...
// дальше идут подпрограммы...
//+------------------------------------------------------------------+
void Fun_New_Bar() // Ф-ия обнаружения ..нового бара
  {
   if(BBars==iBars(Symbol(),SigTfFr)) New_Bar=false;
   if(BBars!=iBars(Symbol(),SigTfFr)) {BBars=iBars(Symbol(),SigTfFr);New_Bar=true;}
  }
//+------------------------------------------------------------------+
// Расчитываем SL TP и цену открытия.
void SLTP() // Расчитываем SL TP
  {
   SStp=0;SSsl=0;BStp=0;BSsl=0;BSotl=0;SSotl=0;
   if(KoefProfit>0) {SStp=A-Razmer*KoefProfit*Point;}
   SSotl=A-Otstup*0.5*Point-Razmer*OtstupProc*Point;
   if(StopLos) SSsl=B+Otstup*Point;

   if(ObeStor) {temp=B;B=A;A=temp;}

   if(KoefProfit>0) {BStp=A+Razmer*KoefProfit*Point;}
   BSotl=A+Otstup*Point+Razmer*OtstupProc*Point;
   if(StopLos) BSsl=B-Otstup/2*Point;

   if(ObeStor) {temp=B;B=A;A=temp;}
  }
//+------------------------------------------------------------------+
// Открываем отложенный ордер
//=-=-=-=-
int OpenOrder(int type)
  {
   MasTekOrder(); // Ищем и заносим в Массив Mas_Ord_Tek все ордера 
   SravMas();
   int err=0;int ticket=0;int c=0;
   if(type==OP_BUYSTOP)
     {
      //   MagicNumber=Massiv[0][1];
      BSotl= NormalizeDouble(BSotl-delta*Point,Digits);
      for(i=1; i<=MaxOrdersetka; i++)
        {
         BSotl= NormalizeDouble(BSotl+delta*Point,Digits);
         for(c=0;c<NumberOfTries;c++)
           {
            ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,BSotl,Slippage,BSsl,BStp,ExpertComment,MagicNumber,0,Green);
            err=GetLastError();
            if(err==0)
              {
               ZapOrdMas(ticket);
               break;
              }
            else
              {
               if(err==4 || err==137 || err==146 || err==136) //Busy errors
                 {
                  Sleep(60);
                  continue;
                 }
               else //normal error
                 {
                  //              ZapOrdMas(ticket);
                  break;
                 }
              }
           }
        }
     }
   if(type==OP_SELLSTOP)
     {
      //   MagicNumber=Massiv[0][1]; 
      SSotl= NormalizeDouble(SSotl+delta*Point,Digits);
      for(i=1; i<=MaxOrdersetka; i++)
        {
         SSotl=NormalizeDouble(SSotl-delta*Point,Digits);
         for(c=0;c<NumberOfTries;c++)
           {
            ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,SSotl,Slippage,SSsl,SStp,ExpertComment,MagicNumber,0,Red);
            err=GetLastError();
            if(err==0)
              {
               ZapOrdMas(ticket);
               break;
              }
            else
              {
               if(err==4 || err==137 || err==146 || err==136) //Busy errors
                 {
                  Sleep(60);
                  continue;
                 }
               else //normal error
                 {
                  //              ZapOrdMas(ticket);
                  break;
                 }
              }
           }
        }
      //   }
     }
// ZapOrdMas(ticket);
//MasTekOrder (); // Ищем и заносим в Массив Mas_Ord_Tek все ордера 
//SravMas();
   return(ticket);
  }
//+------------------------------------------------------------------+
// Закрываем отложенный ордер
bool CloseOrder(int type)

  {
   if(type==OP_BUYSTOP)
      return(OrderDelete(OrderTicket()));
   if(type==OP_SELLSTOP)
      return(OrderDelete(OrderTicket()));
   return (0);
  }
//+------------------------------------------------------------------+
void CheckError(int ticket,string Type)
  {
   if(ticket>0)
     {
      if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) Print(Type+" order opened : ",OrderOpenPrice());
     }
   else Print("Error opening "+Type+" order : ",ErrorDescription(GetLastError()));
  }
//+------------------------------------------------------------------+
//+-  Читаем и пишем в файл  -=-  -----------------------------------+
//+------------------------------------------------------------------+
void FilesWrite() //  Пишем  Massiv --> в Файл (резервное копирование)
  {
   Massiv[0][5]=Massiv[0][5]+1;
   int h=FileOpen("Massiv.bin",FILE_BIN|FILE_WRITE);
   FileWriteInteger(h,ArraySize(Massiv),LONG_VALUE);
   FileWriteArray(h,Massiv,0,ArraySize(Massiv));
   FileClose(h);
  }
//+------------------------------------------------------------------+
void FilesOpen() // Читаем Файл в Massiv -->-- (резервное копирование)
  {
   int h=FileOpen("Massiv.bin",FILE_BIN|FILE_READ);
   if(h<1)
     {
      Print("Файл Massiv.bin не обнаружен, последняя ошибка ",GetLastError());
      return(false);
     }
   int s=FileReadInteger(h,LONG_VALUE);
   ArrayResize(Massiv,s);
   FileReadArray(h,Massiv,0,s);
   FileClose(h);
  }
//+------------------------------------------------------------------+
//+-    -=-  -----------------------------------+
//+------------------------------------------------------------------+   
void MasTekOrder() // Ищем и заносим в Массив "Mas_Ord_Tek" все ордера 
  {
   int Kol=0;                         // Обнуление счётчика ордеров
                                      //   Massiv[0][2]=Massiv[0][1];  //  самый малый магик = Самый большой(сброс)
   ArrayInitialize(Mas_Ord_Tek,0);    // Обнуление массива
   for(i=0; i<OrdersTotal(); i++)// Анализ по всем ордерам терминала
     {
      if((OrderSelect(i,SELECT_BY_POS)==true) && (OrderSymbol()==Symbol()))// && Magic==StrToInteger(StringSubstr(DoubleToStr(OrderMagicNumber(),0), 0, 3)))) //Если есть следующ и наша вал.пара и наш магик
        {
         Kol++;                  // Считаем общее количество ордеров
         //--- Формирование нового массива ордеров --
         Mas_Ord_Tek[Kol][1] = NormalizeDouble(OrderOpenPrice(),Digits); // Курс открытия ордеров
         Mas_Ord_Tek[Kol][2] = NormalizeDouble(OrderStopLoss(), Digits); // Курс SL 
         Mas_Ord_Tek[Kol][3]= NormalizeDouble(OrderTakeProfit(),Digits); // Курс ТР 
         Mas_Ord_Tek[Kol][4] = OrderTicket();     // Номер ордера
         Mas_Ord_Tek[Kol][5] = OrderLots();       // Количество лотов
         Mas_Ord_Tek[Kol][6] = OrderType();       // Тип ордера
         Mas_Ord_Tek[Kol][7] = OrderMagicNumber();// Магическое число 
                                                  //        if (Massiv[0][2]>OrderMagicNumber()) Massiv[0][2]=OrderMagicNumber(); // Ищем самый маленький магик среди открытых ордеров
        }
     }
   Mas_Ord_Tek[0][0]=Kol; // Сохраняем в нулевую ячеечку кол-во ордеров.
                          //   Massiv[0][2]=MinMagicNumber; // Заносим в основной массив самый маленький магик открытых ордеров
//   return();
  }
//==================================================================   
void SravMas() //==================================== Поиск пропавших ордеров ====
  {
   for(int oo=1;oo<=30;oo++) // Возьмём номер ордера из старого массива  
      //   for (int oo=1;oo<=Massiv[0][0];oo++)   // Возьмём номер ордера из старого массива  
     {
      int Sovpadenie=0;     // Для начала обнулим факт признака совпад.                     
      for(i=1;i<=Mas_Ord_Tek[0][0];i++) // Поищем этот ордерок в текущем массиве  
        {
         if(Mas_Ord_Tek[i][4]==Massiv[oo][4]) // Если совпал ticket ордера, то запомним, т.е пока жив
            // и выходим из внутреннего цикла
           {
            Sovpadenie=1;
            if(Massiv[oo][6]!=Mas_Ord_Tek[i][6]) Massiv[oo][6]=Mas_Ord_Tek[i][6]; //изменяем статус ордера                        
            break;
           }
        }
      if(Sovpadenie==1) continue;  // Переходим к следующему старому

      if(Massiv[oo][6]<9) Massiv[oo][6]=Massiv[oo][6]+10;  // Закрыт ордер 
     }
   Massiv[0][3]=0;    // Сброс пустой ячейки для записи ордеров
   for(int f=1;f<=30;f++) // Перебираем весь массив в поисках старых ордеров и их удаления
     {
      if((Massiv[0][3]==0) && (Massiv[f][4]==0)) Massiv[0][3]=f; // если нет ticket значит строка пуста
      if((DelHistoryMassiv) && (Massiv[f][6]>9)) // Если ордера уже нет 
        {
         for(int g=0;g<=7;g++) // Обнуляем всю строку 
           {
            Massiv[f][g]=0;   // заполняем 0
            if(Massiv[0][3]==0) Massiv[0][3]=f;// Запоминаем пустую строку для записи новых ордеров
           }
        }
     }
//   return();
  }
//=================================================================
void ZapOrdMas(int ticket)
  {
   MasTekOrder(); // Ищем и заносим в Массив Mas_Ord_Tek все ордера 
   SravMas();
   int pusto=Massiv[0][3];
   if(pusto==0)
     {
      for(int f=1;f<=30;f++) // Перебираем весь массив в поисках пустых строк
        {
         if((pusto==0) && (Massiv[f][4]==0)) {pusto=f; break;} // если нет ticket значит строка пуста
        }
     }
   for(i=0; i<OrdersTotal(); i++)// Анализ по всем ордерам терминала
     {
      if((OrderSelect(i,SELECT_BY_POS)==true) && (OrderSymbol()==Symbol()) && (ticket==OrderTicket())) //Если есть следующ и наша вал.пара
        {
         if((ObeStor) && (Ak>Bk) && (OrderType()==5)) {temp=B;B=A;A=temp;}  //  buy 
         if((ObeStor) && (Ak<Bk) && (OrderType()==4)) {temp=B;B=A;A=temp;}  //  sell
                                                                            // Ak=hk1;Bk=lk1;  SelSL=A  

         Massiv[pusto][1] = A;// A
         Massiv[pusto][2] = B;// B
         Massiv[pusto][3]=Razmer;// Razmer
         Massiv[pusto][4]=OrderTicket();     // Номер ордера
         Massiv[pusto][5]=Time[0];// Время открытия сделки
         Massiv[pusto][6] = OrderType();       // Тип ордера
         Massiv[pusto][7] = OrderMagicNumber();// Магическое число 
                                               //         Massiv[pusto][8] =    // Период графика принятия решения
         //         Massiv[pusto][9] = 
         Massiv[0][3]=0;
         //         MagicNumber=MagicNumber+1;
         Massiv[0][1]=MagicNumber;
         if((ObeStor) && (Ak>Bk) && (OrderType()==5)) {temp=B;B=A;A=temp;} //   buy 
         if((ObeStor) && (Ak<Bk) && (OrderType()==4)) {temp=B;B=A;A=temp;}  //  sell
         if(SaveMassiv==true)
           {
            FilesWrite();
            //          return(0);
           } //  //  Пишем массив Massiv --> в Файл    
        }
     }
//SravMas();
   return;
  }
//--------------------------------------------------------------------------   
void MasOtmerHod(int ticket)
  {
   for(int m=1;m<=30;m++) //
     {
      if((Massiv[m][4]==ticket)) break; // 
     }
   for(i=0; i<OrdersTotal(); i++)// Анализ по всем ордерам терминала
     {
      if((OrderSelect(i,SELECT_BY_POS)==true) && (OrderSymbol()==Symbol()) && (ticket==OrderTicket())) //Если есть следующ и наша вал.пара
        {
         if((OtmerennyiHod) && ((Massiv[m][6]==0) || (Massiv[m][6]==4))) // buy
           {
            if((DelKorStopOrder>0) && (Massiv[m][6]==4) && ((Massiv[m][2]+Massiv[m][3]*DelKorStopOrder*Point)>iLow(Symbol(),0,1))){CloseOrder(OrderType());}
            OpBar=(iBarShift(Symbol(),0,MTime)+1);
            OtkatBar=iLowest(Symbol(),0,MODE_LOW,OpBar,1);
            OtkatCena=iLow(Symbol(),0,OtkatBar);
            //             Hod=(MB-MA)*100000; // ??? *Point
            //           DelKor
            Hod=MRazmer;
            //             if (Hod<0) {Hod=-Hod;}
            Target=OtkatCena+Hod*KoefProfit*Point;
            OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),Target,0,Yellow);
           }
         if((OtmerennyiHod) && ((Massiv[m][6]==1) || (Massiv[m][6]==5))) //sell
           {
            if((DelKorStopOrder>0) && (Massiv[m][6]==5) && ((Massiv[m][2]-Massiv[m][3]*DelKorStopOrder*Point)<iHigh(Symbol(),0,1))){CloseOrder(OrderType());}
            OpBar=(iBarShift(Symbol(),0,MTime)+1);
            OtkatBar=iHighest(Symbol(),0,MODE_HIGH,OpBar,1);
            OtkatCena=iHigh(Symbol(),0,OtkatBar);
            //             Hod=(MB-MA)*100000; // ??? *Point
            Hod=MRazmer;
            //             if (Hod<0) {Hod=-Hod;}
            Target=OtkatCena-Hod*KoefProfit*Point;// A+Razmer*KoefProfit*Point;
            OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),Target,0,Yellow);
           }
        }
     }
   return;
  }
//--------------------------------------------------------------------------   
void hlFractal()
  {
//+--------------Вычисляем h1-h3
   hk1=0;hk2=0;hk3=0;hk4=0;hf=0;lf=0;
   k=kstart;
   while(hk1<1) //...h1
     {
      hf=iCustom(Symbol(),TfFr,"Fr",BarsFr,0,k);
      if(hf>0) {hk1=k;h1=hf;}
      k++;
     }
   k=k+1;
   while(hk2<1) //...h2
     {
      hf=iCustom(Symbol(),TfFr,"Fr",BarsFr,0,k);
      if(hf>0) {hk2=k;h2=hf;}
      k++;
     }
   k=k+1;
   while(hk3<1) //...h3
     {
      hf=iCustom(Symbol(),TfFr,"Fr",BarsFr,0,k);
      if(hf>0) {hk3=k;h3=hf;}
      k++;
     }
   k=k+1;
   while(hk4<1) //...h4
     {
      hf=iCustom(Symbol(),TfFr,"Fr",BarsFr,0,k);
      if(hf>0) {hk4=k;h4=hf;}
      k++;
     }
//+--------------Вычисляем l1-l3
   lk1=0;lk2=0;lk3=0;lk4=0;
   k=kstart;
   while(lk1<1) //...l1
     {
      lf=iCustom(Symbol(),TfFr,"Fr",BarsFr,1,k);
      if(lf>0) {lk1=k;l1=lf;}
      k++;
     }
   k=k+1;
   while(lk2<1) //...l2
     {
      lf=iCustom(Symbol(),TfFr,"Fr",BarsFr,1,k);
      if(lf>0) {lk2=k;l2=lf;}
      k++;
     }
   k=k+1;
   while(lk3<1) //...l3
     {
      lf=iCustom(Symbol(),TfFr,"Fr",BarsFr,1,k);
      if(lf>0) {lk3=k;l3=lf;}
      k++;
     }
   k=k+1;
   while(lk4<1) //...l4
     {
      lf=iCustom(Symbol(),TfFr,"Fr",BarsFr,1,k);
      if(lf>0) {lk4=k;l4=lf;}
      k++;
     }
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//+-----------------------------------------------------TrailingStop-+
//+------------------------------------------------------------------+
void TralFractal()
  {
   k=0;hTralFr=0;
   hf=0;
   Tmfrm=iTmfrm;
   for(int a=0; a<Frktl_kol; a++) //
     {
      hTralFr=0;
      while(hTralFr<1) //...
        {
         hf=iCustom(Symbol(),Tmfrm,"Fr",Frktl_bars,0,k);
         if(hf>0) hTralFr=k;
         k++;
        }
     }
   k=0;lTralFr=0;
   lf=0;
   for(a=0; a<Frktl_kol; a++) //
     {
      lTralFr=0;
      while(lTralFr<1) //...
        {
         lf=iCustom(Symbol(),Tmfrm,"Fr",Frktl_bars,1,k);
         if(lf>0) lTralFr=k;
         k++;
        }
     }
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
void TrailingByZ(int ticket,int tmfrm,int bars_n,int indent,bool trlinloss)
  {
   TralFractal();
//   int i; // counter
   double new_extremum;

// проверяем переданные значения
   if((indent<0) || (ticket==0) || ((tmfrm!=1) && (tmfrm!=5) && (tmfrm!=15) && (tmfrm!=30) && (tmfrm!=60) && (tmfrm!=240) && (tmfrm!=1440) && (tmfrm!=10080) && (tmfrm!=43200)) || (!OrderSelect(ticket,SELECT_BY_TICKET)))
     {
      Print("Трейлинг функцией TrailingByShadows() невозможен из-за некорректности значений переданных ей аргументов.");
      return(0);
     }

// если длинная позиция (OP_BUY), находим минимум bars_n свечей
   if(OrderType()==OP_BUY)
     {
      if(Frktl_kol>0) // new_extremum = ArrayMinimum(Symbol(),tmfrm,lTralFr);
        {
         //       TralFractal();
         int IndMin=ArrayMinimum(Low,lTralFr,1); // индекс бара
         new_extremum=iLow(Symbol(),tmfrm,IndMin);
        }
      if(Bars_kol>0)
        {
         for(i=1;i<=bars_n;i++)
           {
            if(i==1) new_extremum=iLow(Symbol(),tmfrm,i);
            else
               if(new_extremum>iLow(Symbol(),tmfrm,i)) new_extremum=iLow(Symbol(),tmfrm,i);
           }
        }
      if((BuySL>0) && (SLSignal)) new_extremum=BuySL;

      // если тралим и в зоне убытков
      if(trlinloss==true)
        {
         // если найденное значение "лучше" текущего стоплосса позиции, переносим 
         if((((new_extremum-indent*Point)>OrderStopLoss()) || (OrderStopLoss()==0)) && (new_extremum-indent*Point<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            if(!OrderModify(ticket,OrderOpenPrice(),new_extremum-indent*Point,OrderTakeProfit(),OrderExpiration()))
               Print("Не удалось модифицировать ордер №",OrderTicket(),". Ошибка: ",GetLastError());
        }
      else
        {
         // если новый стоплосс не только лучше предыдущего, но и курса открытия позиции
         if((((new_extremum-indent*Point)>OrderStopLoss()) || (OrderStopLoss()==0)) && ((new_extremum-indent*Point)>OrderOpenPrice()) && (new_extremum-indent*Point<Bid-MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            if(!OrderModify(ticket,OrderOpenPrice(),new_extremum-indent*Point,OrderTakeProfit(),OrderExpiration()))
               Print("Не удалось модифицировать ордер №",OrderTicket(),". Ошибка: ",GetLastError());
        }
     }
// если короткая позиция (OP_SELL), находим минимум bars_n свечей
   if(OrderType()==OP_SELL)
     {
      if(Frktl_kol>0)
        {
         int IndMax=ArrayMaximum(High,hTralFr,1); // индекс бара
         new_extremum=iHigh(Symbol(),tmfrm,IndMax);
        }
      if(Bars_kol>0)
        {
         for(i=1;i<=bars_n;i++)
           {
            if(i==1) new_extremum=iHigh(Symbol(),tmfrm,i);
            else
               if(new_extremum<iHigh(Symbol(),tmfrm,i)) new_extremum=iHigh(Symbol(),tmfrm,i);
            //         if ((Frktl_kol>0) && new_extremum<iHigh(Symbol(),tmfrm,hTralFr)) new_extremum = iHigh(Symbol(),tmfrm,hTralFr);
            //         if (Frktl_kol>0) new_extremum = iHigh(Symbol(),tmfrm,hTralFr);
           }
        }
      if((SelSL>0) && (SLSignal)) new_extremum=SelSL;
      // если тралим и в зоне убытков
      if(trlinloss==true)
        {
         // если найденное значение "лучше" текущего стоплосса позиции, переносим 
         if((((new_extremum+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point)<OrderStopLoss()) || (OrderStopLoss()==0)) && (new_extremum+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            if(!OrderModify(ticket,OrderOpenPrice(),new_extremum+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point,OrderTakeProfit(),OrderExpiration()))
               Print("Не удалось модифицировать ордер №",OrderTicket(),". Ошибка: ",GetLastError());
        }
      else
        {
         // если новый стоплосс не только лучше предыдущего, но и курса открытия позиции
         if((((new_extremum+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point)<OrderStopLoss()) || (OrderStopLoss()==0)) && ((new_extremum+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point)<OrderOpenPrice()) && (new_extremum+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point>Ask+MarketInfo(Symbol(),MODE_STOPLEVEL)*Point))
            if(!OrderModify(ticket,OrderOpenPrice(),new_extremum+(indent+MarketInfo(Symbol(),MODE_SPREAD))*Point,OrderTakeProfit(),OrderExpiration()))
               Print("Не удалось модифицировать ордер №",OrderTicket(),". Ошибка: ",GetLastError());
        }
     }
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |


//+----------------------------------------------------------------------------+
//|  Версия  : 19.02.2008                                                      |
//|  Описание: Закрытие одной предварительно выбранной позиции                 |
//+----------------------------------------------------------------------------+
void ClosePosBySelect() 
  {
   bool   fc;
   color  clClose;
   double ll,pa,pb,pp;
   int    err,it;

   if(OrderType()==OP_BUY || OrderType()==OP_SELL) 
     {
      for(it=1; it<=NumberOfTry; it++) 
        {
         if(!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
         while(!IsTradeAllowed()) Sleep(5000);
         RefreshRates();
         pa=MarketInfo(OrderSymbol(), MODE_ASK);
         pb=MarketInfo(OrderSymbol(), MODE_BID);
         if(OrderType()==OP_BUY) 
           {
            pp=pb; clClose=clCloseBuy;
              } else {
            pp=pa; clClose=clCloseSell;
           }
         ll=OrderLots();
         fc=OrderClose(OrderTicket(), ll, pp, Slippage, clClose);
         if(fc) 
           {
            if(UseSound) PlaySound(SoundSuccess); break;
              } else {
            err=GetLastError();
            if(UseSound) PlaySound(SoundError);
            if(err==146) while(IsTradeContextBusy()) Sleep(1000*11);
            Print("Error(",err,") Close ",GetNameOP(OrderType())," ",
                  ErrorDescription(err),", try ",it);
            Print(OrderTicket(),"  Ask=",pa,"  Bid=",pb,"  pp=",pp);
            Print("sy=",OrderSymbol(),"  ll=",ll,"  sl=",OrderStopLoss(),
                  "  tp=",OrderTakeProfit(),"  mn=",OrderMagicNumber());
            Sleep(1000*5);
           }
        }
     }
   else Print("Некорректная торговая операция. Close ",GetNameOP(OrderType()));
  }
//|  Описание : Возвращает наименование торговой операции                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    op - идентификатор торговой операции                                    |
//+----------------------------------------------------------------------------+
string GetNameOP(int op) 
  {
   switch(op) 
     {
      case OP_BUY      : return("Buy");
      case OP_SELL     : return("Sell");
      case OP_BUYLIMIT : return("BuyLimit");
      case OP_SELLLIMIT: return("SellLimit");
      case OP_BUYSTOP  : return("BuyStop");
      case OP_SELLSTOP : return("SellStop");
      default          : return("Unknown Operation");
     }
  }
//+----------------------------------------------------------------------------+
//|  Описание : Закрытие позиций по рыночной цене сначала прибыльных           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
void ClosePosFirstProfit(string sy="",int op=-1,int mn=-1) 
  {
   k=OrdersTotal();
   if(sy=="0") sy=Symbol();

// Сначала закрываем прибыльные позиции
   for(i=k-1; i>=0; i--) 
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) 
        {
         if((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) 
           {
            if(OrderType()==OP_BUY || OrderType()==OP_SELL) 
              {
               if(mn<0 || OrderMagicNumber()==mn) 
                 {
                  if(OrderProfit()+OrderSwap()>0) ClosePosBySelect();
                 }
              }
           }
        }
     }
// Потом все остальные
   k=OrdersTotal();
   for(i=k-1; i>=0; i--) 
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) 
        {
         if((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) 
           {
            if(OrderType()==OP_BUY || OrderType()==OP_SELL) 
              {
               if(mn<0 || OrderMagicNumber()==mn) ClosePosBySelect();
              }
           }
        }
     }
  }
//|  Описание : Удаление ордеров                                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любой ордер)                    |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
void DeleteOrders(string sy="",int op=-1,int mn=-1) 
  {
   bool fd;
   int  err,it,ot;
   k=OrdersTotal();
   if(sy=="0") sy=Symbol();
   for(i=k-1; i>=0; i--) 
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) 
        {
         ot=OrderType();
         if(ot>1 && ot<6) 
           {
            if((OrderSymbol()==sy || sy=="") && (op<0 || ot==op)) 
              {
               if(mn<0 || OrderMagicNumber()==mn) 
                 {
                  for(it=1; it<=NumberOfTry; it++) 
                    {
                     if(!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
                     while(!IsTradeAllowed()) Sleep(5000);
                     fd=OrderDelete(OrderTicket(),clDelete);
                     if(fd) 
                       {
                        if(UseSound) PlaySound(SoundSuccess); break;
                          } else {
                        err=GetLastError();
                        if(UseSound) PlaySound(SoundError);
                        Print("Error(",err,") delete order ",GetNameOP(ot),": ",ErrorDescription(err),", try ",it);
                        Sleep(1000*5);
                       }
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+