1.Функцию PutOrder вообще не надо было редактировать, а просто взять готовую у АМ2

Вот например:

//+------------------------------------------------------------------+
void PutOrder(int type,double price)
{
int r=0;
color clr=Green;
double sl=0,tp=0;

if(type==1 || type==3 || type==5)
{
clr=Red;
if(StopLoss>0) sl=NormalizeDouble(price+StopLoss*Point,Digits);
if(TakeProfit>0) tp=NormalizeDouble(price-TakeProfit*Point,Digits);
}

if(type==0 || type==2 || type==4)
{
clr=Blue;
if(StopLoss>0) sl=NormalizeDouble(price-StopLoss*Point,Digits);
if(TakeProfit>0) tp=NormalizeDouble(price+TakeProfit*Point,Digits);
}

r=OrderSend(NULL,type,Lots,NormalizeDouble(price,Digits),Slip,sl,tp,"",Magic,0,clr);
return;
}
//+------------------------------------------------------------------+

А дальше в функции OnTick прописываете отдельно два условия: одно для открытия сделок на покупку, одно для условия сделок на продажу

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
if(Условие для покупок)
{
PutOrder(0,Ask);
}
else
if(Условие для продаж)
{
PutOrder(1,Bid);
}
}
//+------------------------------------------------------------------+

Или для вас принципиально, чтобы функция PutOrder у вас была своя.

Так я вам открою маленкую тайну: ни ваша, ни функция АМ2 не предназначена для торговли на реальном счёте(время от времени советник будет пропускать сигналы на вход(это я про реальный счёт говорю), пускай даже в тестере вы подберёте практически граальные настройки, на реале пара пропущенных сделок могут очень сильго сократить прибыль), так как в функции нет проверок.

Поэтому не мучайтесь: ни чего у вас не выйдет.
Ни кто не выложил в свободный доступ подобную функцию.
Игорь Ким выкладывал в 2008 году, но она сильно морально устарела(время от времени тоже пропускает входы).
Правда не так часто как функция PutOrder.Это я про упращённый вариант функции(на котором вы пытаетесь написать советник).
У АМ2 есть функция улучшеный вариант функции PutOrder (для торговли на реальном счёте)но этот вариант тоже время от времени пропускает сделки.

Потому что у вас прописано: тип операции покупки

op = NP((dir==OP_BUY)

Поэтому только покупки открываются.

Вот вторая часть

<code>//+------------------------------------------------------------------+
void SELLCLOSELimit()
  {
   bool cl;
   //int Slip=10;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol())
           {
            if (OrderType()==OP_SELLLIMIT ) bool del=OrderDelete(OrderTicket());
            RefreshRates();
           }
           }
           }
   }
 
//+------------------------------------------------------------------+
int start()
  {
   double buy  = iCustom(NULL,0,IndName,PROC,StartHourr,StartMinute,EndHourr,EndMinute,0,2);
   double sell = iCustom(NULL,0,IndName,PROC,StartHourr,StartMinute,EndHourr,EndMinute,1,2);
   double bTP  = iCustom(NULL,0,IndName,PROC,StartHourr,StartMinute,EndHourr,EndMinute,2,0);
   double sSL =  iCustom(NULL,0,IndName,PROC,StartHourr,StartMinute,EndHourr,EndMinute,3,0);
   
  
   if(BULevel>0) BU();
      
      if(CountBYU1()>0){ SELLCLOSE();BUYCLOSE();SELLCLOSELimit();}
      if(CountSELL1()>0){ BUYCLOSE();SELLCLOSE();BUYCLOSELimit();}
      if(CountBYU2()>0){ SELLCLOSE();BUYCLOSE();BUYCLOSELimit();SELLCLOSELimit();Trailing();}
      if(CountSELL2()>0){ BUYCLOSE();SELLCLOSE();SELLCLOSELimit();BUYCLOSELimit();Trailing();}
   
      
            
      
       if (CountTrades()==0)
       {
       OrderSend(Symbol(),OP_BUYSTOP,Lots,buy,Slip,sell,bTP,"",Magic,0,Blue);
       OrderSend(Symbol(),OP_SELLSTOP,Lots,sell,Slip,buy,sSL,"",Magic,0,Red);
      if (Limit==True){
       OrderSend(Symbol(),OP_BUYLIMIT,Lots*KLot,sell-Shag*2*Point,Slip,0,0,"",Magic,0,Blue);
       OrderSend(Symbol(),OP_SELLLIMIT,Lots*KLot,buy+Shag*2*Point,Slip,0,0,"",Magic,0,Red);
           }
       }
       
       int h=TimeHour(TimeCurrent()); 
       int m=TimeMinute(TimeCurrent());    
       if (h==EndHour && m>EndMinute) { BUYCLOSE();SELLCLOSE();SELLCLOSELimit();BUYCLOSELimit(); }
          
           return(0);
 
 
  }
</code>

В качестве подсказки должно подойти.
Пробуйте может вас этот вариант устроит
P.S. если не устроит то удалите мои коментарии, а то ваш коментарий затеряется и Андрей его не прочитает.

Вот вариант для мт4

#property copyright "GDV"
#property link      "GDV"
#property version   "1.00"
#property strict

extern double Lots       = 1.0;         // лот
extern double KLot       = 2;           // умножение лота
extern double MaxLot     = 5;           // максимальный лот
extern int Shag          = 100;         // Отступ от SL для удвоения
extern bool Limit        = False;       // False(откл. лимитные ордера) True (вкл.)
extern int BULevel       = 0;           // уровень БУ
extern int BUPoint       = 30;          // пункты БУ
extern int TrailingStop  = 100;         // трал
extern int Slip          = 10;          // Проскальзывание цены
extern string IndName="MorningFlat_V3"; // Название индикатора
extern double PROC=0.5;                 // Процент выставления ТР и SL 
extern int StartHourr=0;                // Час начала инд
extern int StartMinute=15;              // Мин начала инд
extern int EndHourr=8;                  // Час окончания инд
extern int EndMinute=45;                // Мин окончания инд
extern int Magic         = 1;           // Magic
extern int EndHour       = 23;          // час окончания торговли
int OnInit()
  {
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  
  }
int CountTrades()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() )
           {
            if(OrderType()==OP_BUY || OrderType()==OP_BUYSTOP || OrderType()==OP_SELL || OrderType()==OP_SELLSTOP) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
void ClosePos(int ot=-1)
  {
   bool cl;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0 && (ot==0 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,Digits),Slip,White);
              }
            if(OrderType()==1 && (ot==1 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,Digits),Slip,White);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
void Trailing()
  {
   bool mod;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(Bid-OrderOpenPrice()>TrailingStop*Point)
                 {
                  if(OrderStopLoss()<Bid-TrailingStop*Point)
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),Bid-TrailingStop*Point,OrderTakeProfit(),0,Yellow);
                     return;
                    }
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if((OrderOpenPrice()-Ask)>TrailingStop*Point)
                 {
                  if((OrderStopLoss()>(Ask+TrailingStop*Point)) || (OrderStopLoss()==0))
                    {
                     mod=OrderModify(OrderTicket(),OrderOpenPrice(),Ask+TrailingStop*Point,OrderTakeProfit(),0,Yellow);
                     return;
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
void BU()
  {
   bool m;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(OrderOpenPrice()<=(Bid-(BULevel+BUPoint)*Point) && OrderOpenPrice()>OrderStopLoss())
                 {
                  m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()+BUPoint*Point,OrderTakeProfit(),0,Green);
                  return;
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if(OrderOpenPrice()>=(Ask+(BULevel+BUPoint)*Point) && OrderOpenPrice()<OrderStopLoss())
                 {
                  m=OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice()-BUPoint*Point,OrderTakeProfit(),0,Green);
                  return;
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
double AllProfit(int type=-1)
  {
   double profit=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type) profit+=OrderProfit()+OrderCommission()+OrderSwap();
            if(type==-1)
              {
               if(OrderType()<2) profit+=OrderProfit()+OrderCommission()+OrderSwap();
              }
           }
        }
     }
   return (profit);
  }
//+------------------------------------------------------------------+
bool isTradeTimeInt(int hb=0,int mb=0,int he=0,int me=0)
  {
   datetime db, de;           // Время начала и окончания работы
   int      hc;               // Часы текущего времени торгового сервера

   db=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+(string)hb+":"+(string)mb);
   de=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+(string)he+":"+(string)me);
   hc=TimeHour(TimeCurrent());

   if(db>=de)
     {
      if(hc>=he) de+=24*60*60; else db-=24*60*60;
     }

   if(TimeCurrent()>=db && TimeCurrent()<=de) return(True);
   else return(False);
  }
//+------------------------------------------------------------------+
  int CountBYU2()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
     if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
     {
     if(OrderSymbol()==Symbol() )
     {
     if (OrderLots()==Lots*KLot)
     {
     if(OrderType()==OP_BUY) count++;
     }
     }
     }
     }
   return(count);
  }
//-----------------------------------------------------------------------------------------------------  
  int CountSELL2()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
      {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
      if(OrderSymbol()==Symbol())
      {
      if (OrderLots()==Lots*KLot)
      {
      if(OrderType()==OP_SELL) count++;
      }
      }
      }
      }
   return(count);
  }
 //+------------------------------------------------------------------+
 //+------------------------------------------------------------------+
  int CountBYU1()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
     if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
     {
     if(OrderSymbol()==Symbol() )
     {
     if (OrderLots()==Lots)
     {
     if(OrderType()==OP_BUY) count++;
     }
     }
     }
     }
   return(count);
  }
//-----------------------------------------------------------------------------------------------------  
  int CountSELL1()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
      {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
      if(OrderSymbol()==Symbol())
      {
      if (OrderLots()==Lots)
      {
      if(OrderType()==OP_SELL) count++;
      }
      }
      }
      }
   return(count);
  }
 //+------------------------------------------------------------------+
void BUYCLOSE()
  {
   bool cl;
   //int Slip=10;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol())
           {
            if (OrderType()==OP_BUYSTOP ) cl=OrderDelete(OrderTicket());
            
               RefreshRates();
           }
           }
           }
  }
//+------------------------------------------------------------------+
void SELLCLOSE()
  {
   bool cl;
   //int Slip=10;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol())
           {
            if (OrderType()==OP_SELLSTOP ) bool del=OrderDelete(OrderTicket());  
           
            RefreshRates();
           }
           }
           }
   }
  //+------------------------------------------------------------------+
void BUYCLOSELimit()
  {
   bool cl;
   //int Slip=10;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol())
           {
            if (OrderType()==OP_BUYLIMIT ) cl=OrderDelete(OrderTicket());
               RefreshRates();
           }
           }
           }
  }
//+------------------------------------------------------------------+

Это первая часть
Судя по коду это советник АМ2.

Вот версия для мт5

www.opentraders.ru/downloads/3054/

Вы и про первые свои советники так говорили.
Только похоже ими ни чего не зарабатываете, если только и делаете, что заказываете всё новые и новые советники.
А на самом деле вы похоже или просто интригуете новичков, чтобы «впарить им грааль», или хотите чтоб вам завидовали.

Он в формате ex4

А может красная линия индикатора, наоборот падение.Ведь был же рост на предыдущей синий линии.

Как раз-то там всё понятно.Просто Игрун не как не поймёт, что программисты слишком далеки от трейдинга:
на последнем развороте стохастика строится уровень для покупок, а на предпоследнем для продаж.
Со стохастиком в зоне перекупленности(выше уровня)с точностью наоборот
Скорей всего ему не напишут или напишут но не то.Будет ему наука.

Вашу версию не тестировал.Тут несколько версий с одинаковым названием.

Про то что вам нужно мы вас поняли, это ответ адресован nidftgh

Точь в точь нету.
Почти тоже самое заказывали(но что то там не совсем коректно работало: исправили или нет незнаю).Увеличение там умножается на коэфициент.
Если к примеру коэфициент 2, то открытия сделок происходит следующей лотностью:0.1;0.2;0.4;0.8;1.6 и так далее
если коэфициент 3, то открытия сделок происходит следующей лотностью:0.1;0.3;0.9;2.7;8.1 и так далее

что этим можно зарабатывать деньги и только он знает как

А я про нас и не говорил.Я говорил про вас, то что именно только вы можете этим зарабатывать деньги.

ZERNO, не заморачивайтесь,marattmb про каждое своё тех.задание так говорит(чуть ли не с пеной у рта), что этим можно зарабатывать деньги и только он знает как(почитайте его топики и всё поймёте).
Но на деле этим заработать по ним не возиожно, и он вновь и вновь заказывает что-то новое.
В следующем месяце он про эту стратегую и не вспомнит и будет в очередной раз пиарить новую супер-пупер систему.

Это обычный диванный теоретик.Такие зарабатывают не трейдингом, а прдажей своих систем.

Ну на богатей не жалко.

<code>//+------------------------------------------------------------------+
//|                                                  HedgeMartin.mq4 |
//|                                              Copyright 2016, AM2 |
//|                                             www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, AM2"
#property link      "http://forexsystems.biz"
#property version   "1.00"
#property strict

//--- Inputs
extern double Loss           = 9000;      // убыток в валюте
extern double Profit         = 10;        // профит в валюте
extern double Lots           = 0.1;       // лот
extern int    Delta          = 100;       // дельта
extern int    Slip           = 30;        // проскальзывание
extern int    Magic          = 123;       // магик
double lt[26]={0.1,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2};
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
 
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type,double price)
  {
   int r=0;
   color clr=Green;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
     }

   r=OrderSend(NULL,type,Lot(),NormalizeDouble(price,Digits),Slip,0,0,"",Magic,0,clr);
   return;
  }
//+------------------------------------------------------------------+
int CountTrades()
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic || OrderMagicNumber()==0))
           {
            if(OrderType()<2) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int LastOrderType()
  {
   int type=0;
   if(OrderSelect(OrdersTotal()-1,SELECT_BY_POS,MODE_TRADES))
     {
      if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic || OrderMagicNumber()==0))
        {
         if(OrderType()==OP_BUY)  type=1; //buy
         if(OrderType()==OP_SELL) type=2; //sell
        }
     }
   return(type);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double LastOrderOpenPrice()
  {
   double pr=0;
   if(OrderSelect(OrdersTotal()-1,SELECT_BY_POS,MODE_TRADES))
     {
      if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic || OrderMagicNumber()==0))
        {
         if(OrderType()<2) pr=OrderOpenPrice();
        }
     }
   return(pr);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAll(int ot=-1)
  {
   bool cl;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic || OrderMagicNumber()==0))
           {
            if(OrderType()==0 && (ot==0 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,Digits),Slip,White);
              }
            if(OrderType()==1 && (ot==1 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,Digits),Slip,White);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double AllProfit()
  {
   double profit=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic || OrderMagicNumber()==0))
           {
            if(OrderType()<2) profit+=OrderProfit()+OrderSwap()+OrderCommission();
           }
        }
     }
   return(profit);
  }
//+------------------------------------------------------------------+
double Lot()
  {
   double lot=lt[CountTrades()];
   return(lot);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
/*double Lot()
  {
   double lot=Lots;
   if(CountTrades()>0) lot=NormalizeDouble(Lots*MathPow(KLot,CountTrades()),2);
   if(lot>MaxLot)lot=Lots;
   return(lot);
  }*/
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && (OrderMagicNumber()==Magic || OrderMagicNumber()==0))
           {
            if(OrderType()==type) count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DelOrder()
  {
   bool del;
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()>1) del=OrderDelete(OrderTicket());
           }
        }
     }
   return;
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   double delta=(double)ObjectGetString(0,"D",OBJPROP_TEXT);

// открытие первого ордера 
   if(CountTrades()<1 )
     {
      PutOrder(0,Ask);
     }

   if(CountTrades()<1) DelOrder();

// открытие последующих ордеров
   if(CountTrades()>0)
     {
      if(LastOrderType()==1)
        {
         if(CountOrders(5)<1) PutOrder(5,LastOrderOpenPrice()-delta*Point);
        }

      if(LastOrderType()==2)
        {
         if(CountOrders(4)<1) PutOrder(4,LastOrderOpenPrice()+delta*Point);
        }
     }

   if(AllProfit()>Profit || AllProfit()<-Loss)
     {
      CloseAll();
      DelOrder();
     }

   Comment("\n Profit: ",DoubleToString(AllProfit(),2),
           "\n Last Order Type: ",LastOrderType(),
           "\n Count Trades: ",CountTrades(),
           "\n Delta: ",delta);
  }
//+------------------------------------------------------------------+
</code>

P.S. Восемнадцатую строчку редактируйте в соответствии с вашими запросами(размером лота)

А тогда понятно.Как всегда вы у нас самый исключительный.По вашей супер стратегии советник был написан аж в 2009 году.И его тогда скачало очень много народа, но только вы знаете как им зарабатывать.

Здесь на этом сайте по вашей как вы выражаетесь

Фактически, стратегия является без убыточной

аж пять штук различных ссоветников.Всех их обьуденяет одно название «HedgeMartin» и даже есть один, а может уже и два в МТ5.(Поищите в базе)
Так что поздравляю скоро вы станете деньги мешками зарабатывать.

Извините, но предложеная мной версия уже сильно отличается(просто названия совпали)

Ничего, просто добавил две функции АМ2.Если бы умел писать то написал бы свои функции наподобие остальных присутствующих в советнике.