double Ask

int Bars

int Bars=Bars(_Symbol,_Period);

double Bid

double Close[]

double Close[];
int count;        // сколько копируем
ArraySetAsSeries(Close,true);
CopyClose(_Symbol,_Period,0,count,Close);

int Digits

int Digits=_Digits;

double High[]

double High[];
int count;        // сколько копируем
ArraySetAsSeries(High,true);
CopyHigh(_Symbol,_Period,0,count,High);

double Low[]

double Low[];
int count;        // сколько копируем
ArraySetAsSeries(Low,true);
CopyLow(_Symbol,_Period,0,count,Low);

double Open[]

double Open[];
int count;        // сколько копируем
ArraySetAsSeries(Open,true);
CopyOpen(_Symbol,_Period,0,count,Open);

double Point

double Point=_Point;

datetime Time[]

datetime Time[];
int count;        // сколько копируем
ArraySetAsSeries(Time,true);
CopyTime(_Symbol,_Period,0,count,Time);

double Volume[]

long Volume[];
int count;        // сколько копируем
ArraySetAsSeries(Volume,true);
CopyTickVolume(_Symbol,_Period,0,count,Volume);

double AccountBalance()

double AccountInfoDouble(ACCOUNT_BALANCE)

double AccountCredit()

double AccountInfoDouble(ACCOUNT_CREDIT)

string AccountCompany()

string AccountInfoString(ACCOUNT_COMPANY)

string AccountCurrency()

string AccountInfoString(ACCOUNT_CURRENCY)

double AccountEquity()

double AccountInfoDouble(ACCOUNT_EQUITY)

double AccountFreeMargin()

double AccountInfoDouble(ACCOUNT_FREEMARGIN)

double AccountFreeMarginCheck(string symbol,
                              int cmd,
                              double volume)

double AccountFreeMarginMode()

int AccountLeverage()

long AccountInfoInteger(ACCOUNT_LEVERAGE)

double AccountMargin()

double AccountInfoDouble(ACCOUNT_MARGIN)

string AccountName()

string AccountInfoString(ACCOUNT_NAME)

int AccountNumber()

long AccountInfoInteger(ACCOUNT_LOGIN)

double AccountProfit()

double AccountInfoDouble(ACCOUNT_PROFIT)

string AccountServer()

string AccountInfoString(ACCOUNT_SERVER)

int AccountStopoutLevel()

double AccountInfoDouble(ACCOUNT_MARGIN_SO_SO)

int AccountStopoutMode()

int AccountInfoInteger(ACCOUNT_MARGIN_SO_MODE)

int ArrayBsearch(double array[],
                 double value,
                 int count=WHOLE_ARRAY,
                 int start=0,
                 int direction=MODE_ASCEND)

int ArrayBsearch(double    array[],
                 double    searched_value
                 )

int ArrayCopy(object &dest[],
              object source[],
              int start_dest=0,
              int start_source=0,
              int count=WHOLE_ARRAY)

int ArrayCopy(void  dst_array[],
              void  src_array[],
              int   dst_start=0,
              int   src_start=0,
              int   cnt=WHOLE_ARRAY
              )

int ArrayCopyRates(double &dest_array[],
                   string symbol=NULL,
                   int timeframe=0)

int ArrayCopySeries(double &array[],
                    int series_index,
                    string symbol=NULL,
                    int timeframe=0)

int ArrayCopySeriesMQL4(double &array[],
                        int series_index,
                        string symbol,
                        int tf=0)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int count=Bars(symbol,timeframe);
   switch(series_index)
     {
      case MODE_OPEN:
         return(CopyOpen(symbol,timeframe,0,count,array));
      case MODE_LOW:
         return(CopyLow(symbol,timeframe,0,count,array));
      case MODE_HIGH:
         return(CopyHigh(symbol,timeframe,0,count,array));
      case MODE_CLOSE:
         return(CopyClose(symbol,timeframe,0,count,array));

      default: return(0);
     }
   return(0);
  }

int ArrayDimension(object array[])

bool ArrayGetAsSeries(object array[])

bool ArrayGetAsSeries(void  array)

int ArrayInitialize(double &array[],
                    double value)

int ArrayInitializeMQL4(double &array[],
                        double value)
  {
   ArrayInitialize(array,value);
   return(ArraySize(array));
  }

bool ArrayIsSeries(object array[])

bool ArrayIsSeries(void  array[])

int ArrayMaximum(double array[],
                 int count=WHOLE_ARRAY,
                 int start=0)

int ArrayMaximumMQL4(double &array[],
                     int count=WHOLE_ARRAY,
                     int start=0)
  {
   return(ArrayMaximum(array,start,count));
  }

int ArrayMinimum(double array[],
                 int count=WHOLE_ARRAY,
                 int start=0)

int ArrayMinimumMQL4(double &array[],
                     int count=WHOLE_ARRAY,
                     int start=0)
  {
   return(ArrayMinimum(array,start,count));
  }

int ArrayRange(object array[],
               int range_index)

int ArrayRange(void  array[],
               int   rank_index
               )

int ArrayResize(object &array[],
                int new_size)

int ArrayResize(void  array[],
                int   new_size,
                int   allocated_size=0
                )

bool ArraySetAsSeries(double &array[],
                      bool set)

bool ArraySetAsSeries(void  array[],
                      bool  set
                      )

int ArraySize(object array[])

int ArraySize(void  array[])

int ArraySort(double &array[],
              int count=WHOLE_ARRAY,
              int start=0,
              int sort_dir=MODE_ASCEND)

int ArraySortMQL4(double &array[],
                  int count=WHOLE_ARRAY,
                  int start=0,
                  int sort_dir=MODE_ASCEND)
  {
   switch(sort_dir)
     {
      case MODE_ASCEND:
         ArraySetAsSeries(array,true);
      case MODE_DESCEND:
         ArraySetAsSeries(array,false);

      default: ArraySetAsSeries(array,true);
     }
   ArraySort(array);
   return(0);
  }

int GetLastError()

int GetLastError()

bool IsConnected()

bool TerminalInfoInteger(TERMINAL_CONNECTED)

bool IsDemo()

bool IsDemoMQL4()
  {
   if(AccountInfoInteger(ACCOUNT_TRADE_MODE)==ACCOUNT_TRADE_MODE_DEMO)
      return(true);
   else
      return(false);
  }

bool IsDllsAllowed()

bool TerminalInfoInteger(TERMINAL_DLLS_ALLOWED)

bool IsExpertEnabled()

bool AccountInfoInteger(ACCOUNT_TRADE_EXPERT)

bool IsLibrariesAllowed()

bool MQLInfoInteger(MQL5_DLLS_ALLOWED)

bool IsOptimization()

bool MQLInfoInteger(MQL5_OPTIMIZATION)

bool IsStopped()

bool IsStopped()

bool IsTesting()

bool MQLInfoInteger(MQL5_TESTING)

bool IsTradeAllowed()

bool MQLInfoInteger(MQL5_TRADE_ALLOWED)

bool IsTradeContextBusy()

bool IsVisualMode()

bool MQLInfoInteger(MQL5_VISUAL_MODE)

int UninitializeReason()

int UninitializeReason()

string TerminalCompany()

string TerminalInfoString(TERMINAL_COMPANY)

string TerminalName()

string TerminalInfoString(TERMINAL_NAME)

string TerminalPath()

string TerminalInfoString(TERMINAL_PATH)

void Alert(...)

void Alert(argument,...)

void Comment(...)

void Comment(argument,...)

int GetTickCount()

uint GetTickCount()

double MarketInfo(string symbol,
                  int type)

double MarketInfoMQL4(string symbol,
                      int type)
  {
   switch(type)
     {
      case MODE_LOW:
         return(SymbolInfoDouble(symbol,SYMBOL_LASTLOW));
      case MODE_HIGH:
         return(SymbolInfoDouble(symbol,SYMBOL_LASTHIGH));
      case MODE_TIME:
         return(SymbolInfoInteger(symbol,SYMBOL_TIME));
      case MODE_BID:
        {
         MqlTick last_tick;
         SymbolInfoTick(symbol,last_tick);
         double Bid=last_tick.bid;
         return(Bid);
        }
      case MODE_ASK:
        {
         MqlTick last_tick;
         SymbolInfoTick(symbol,last_tick);
         double Ask=last_tick.ask;
         return(Ask);
        }
      case MODE_POINT:
         return(SymbolInfoDouble(symbol,SYMBOL_POINT));
      case MODE_DIGITS:
         return(SymbolInfoInteger(symbol,SYMBOL_DIGITS));
      case MODE_SPREAD:
         return(SymbolInfoInteger(symbol,SYMBOL_SPREAD));
      case MODE_STOPLEVEL:
         return(SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL));
      case MODE_LOTSIZE:
         return(SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE));
      case MODE_TICKVALUE:
         return(SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE));
      case MODE_TICKSIZE:
         return(SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_SIZE));
      case MODE_SWAPLONG:
         return(SymbolInfoDouble(symbol,SYMBOL_SWAP_LONG));
      case MODE_SWAPSHORT:
         return(SymbolInfoDouble(symbol,SYMBOL_SWAP_SHORT));
      case MODE_STARTING:
         return(0);
      case MODE_EXPIRATION:
         return(0);
      case MODE_TRADEALLOWED:
         return(0);
      case MODE_MINLOT:
         return(SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN));
      case MODE_LOTSTEP:
         return(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP));
      case MODE_MAXLOT:
         return(SymbolInfoDouble(symbol,SYMBOL_VOLUME_MAX));
      case MODE_SWAPTYPE:
         return(SymbolInfoInteger(symbol,SYMBOL_SWAP_MODE));
      case MODE_PROFITCALCMODE:
         return(SymbolInfoInteger(symbol,SYMBOL_TRADE_CALC_MODE));
      case MODE_MARGINCALCMODE:
         return(0);
      case MODE_MARGININIT:
         return(0);
      case MODE_MARGINMAINTENANCE:
         return(0);
      case MODE_MARGINHEDGED:
         return(0);
      case MODE_MARGINREQUIRED:
         return(0);
      case MODE_FREEZELEVEL:
         return(SymbolInfoInteger(symbol,SYMBOL_TRADE_FREEZE_LEVEL));

      default: return(0);
     }
   return(0);
  }

int MessageBox(string text=NULL,
               string caption=NULL,
               int flags=EMPTY)

int MessageBox(string  text,
               string  caption=NULL,
               int     flags=0)

void PlaySound(string filename)

bool PlaySound(string filename)

void Print(...)

void Print(argument,...)

bool SendFTP(string filename,
             string ftp_path=NULL)

bool SendFTP(string filename,
             string ftp_path=NULL)

void SendMail(string subject,
              string some_text)

bool SendMail(string  subject,
              string  some_text)

void Sleep(int milliseconds)

void Sleep(int milliseconds)

string CharToStr(int char_code)

string CharToString(int char_code)

string DoubleToStr(double value,
                   int digits)

string DoubleToString(double value,
                      int digits=8)

double NormalizeDouble(double value,
                       int digits)

double NormalizeDouble(double value,
                       int digits)

double StrToDouble(string value)

double StringToDouble(string value)

int StrToInteger(string value)

long StringToInteger(string value)

datetime StrToTime(string value)

datetime StringToTime(string value)

string TimeToStr(datetime value,
                 int mode=TIME_DATE|TIME_MINUTES)

string TimeToString(datetime value,
                    int mode=TIME_DATE|TIME_MINUTES)

void IndicatorBuffers(int count)

int IndicatorCounted()

int IndicatorCountedMQL4()
  {
   if(prev_calculated>0) return(prev_calculated-1);
   if(prev_calculated==0) return(0);
   return(0);
  }

void IndicatorDigits(int digits)

bool IndicatorSetInteger(INDICATOR_DIGITS,digits)

void IndicatorShortName(string name)

bool IndicatorSetString(INDICATOR_SHORTNAME,name)

void SetIndexArrow(int index,
                   int code)

bool PlotIndexSetInteger(index,PLOT_ARROW,code)

bool SetIndexBuffer(int index,
                    double array[])

bool SetIndexBuffer(index,array,INDICATOR_DATA)

void SetIndexDrawBegin(int index,
                       int begin)

bool PlotIndexSetInteger(index,PLOT_DRAW_BEGIN,begin)

void SetIndexEmptyValue(int index,
                        double value)

bool PlotIndexSetDouble(index,PLOT_EMPTY_VALUE,value)

void SetIndexLabel(int index,
                   string text)

bool PlotIndexSetString(index,PLOT_LABEL,text)

void SetIndexShift(int index,
                   int shift)

bool PlotIndexSetInteger(index,PLOT_SHIFT,shift)

void SetIndexStyle(int index,
                   int type,
                   int style=EMPTY,
                   int width=EMPTY,
                   color clr=CLR_NONE)

void SetIndexStyleMQL4(int index,
                       int type,
                       int style=EMPTY,
                       int width=EMPTY,
                       color clr=CLR_NONE)
  {
   if(width>-1)
      PlotIndexSetInteger(index,PLOT_LINE_WIDTH,width);
   if(clr!=CLR_NONE)
      PlotIndexSetInteger(index,PLOT_LINE_COLOR,clr);
   switch(type)
     {
      case 0:
         PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_LINE);
      case 1:
         PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_SECTION);
      case 2:
         PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_HISTOGRAM);
      case 3:
         PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_ARROW);
      case 4:
         PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_ZIGZAG);
      case 12:
         PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_NONE);

      default:
         PlotIndexSetInteger(index,PLOT_DRAW_TYPE,DRAW_LINE);
     }
   switch(style)
     {
      case 0:
         PlotIndexSetInteger(index,PLOT_LINE_STYLE,STYLE_SOLID);
      case 1:
         PlotIndexSetInteger(index,PLOT_LINE_STYLE,STYLE_DASH);
      case 2:
         PlotIndexSetInteger(index,PLOT_LINE_STYLE,STYLE_DOT);
      case 3:
         PlotIndexSetInteger(index,PLOT_LINE_STYLE,STYLE_DASHDOT);
      case 4:
         PlotIndexSetInteger(index,PLOT_LINE_STYLE,STYLE_DASHDOTDOT);

      default: return;
     }
  }

void SetLevelStyle(int draw_style,
                   int line_width,
                   color clr=CLR_NONE)

void SetLevelStyleMQL4(int draw_style,
                       int line_width,
                       color clr=CLR_NONE)
  {
   IndicatorSetInteger(INDICATOR_LEVELWIDTH,line_width);
   if(clr!=CLR_NONE)
      IndicatorSetInteger(INDICATOR_LEVELCOLOR,clr);
   switch(draw_style)
     {
      case 0:
         IndicatorSetInteger(INDICATOR_LEVELSTYLE,STYLE_SOLID);
      case 1:
         IndicatorSetInteger(INDICATOR_LEVELSTYLE,STYLE_DASH);
      case 2:
         IndicatorSetInteger(INDICATOR_LEVELSTYLE,STYLE_DOT);
      case 3:
         IndicatorSetInteger(INDICATOR_LEVELSTYLE,STYLE_DASHDOT);
      case 4:
         IndicatorSetInteger(INDICATOR_LEVELSTYLE,STYLE_DASHDOTDOT);

      default: return;
     }
  }

void SetLevelValue(int level,
                   double value)

bool IndicatorSetDouble(INDICATOR_LEVELVALUE,level,value)

int Day()

int DayMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.day);
  }

int DayOfWeek()

int DayOfWeekMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.day_of_week);
  }

int DayOfYear()

int DayOfYearMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.day_of_year);
  }

int Hour()

int HourMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.hour);
  }

int Minute()

int MinuteMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.min);
  }

int Month()

int MonthMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.mon);
  }

int Seconds()

int SecondsMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.sec);
  }

datetime TimeCurrent()

datetime TimeCurrent()

int TimeDay(datetime date)

int TimeDayMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.day);
  }

int TimeDayOfWeek(datetime date)

int TimeDayOfWeekMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.day_of_week);
  }

int TimeDayOfYear(datetime date)

int TimeDayOfYearMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.day_of_year);
  }

int TimeHour(datetime time)

int TimeHourMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.hour);
  }

datetime TimeLocal()

datetime TimeLocal()

int TimeMinute(datetime time)

int TimeMinuteMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.min);
  }

int TimeMonth(datetime time)

int TimeMonthMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.mon);
  }

int TimeSeconds(datetime time)

int TimeSecondsMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.sec);
  }

int TimeYear(datetime time)

int TimeYearMQL4(datetime date)
  {
   MqlDateTime tm;
   TimeToStruct(date,tm);
   return(tm.year);
  }

int Year()

int YearMQL4()
  {
   MqlDateTime tm;
   TimeCurrent(tm);
   return(tm.year);
  }

void FileClose(int handle)

void FileClose(int file_handle)

void FileDelete(string filename)

bool FileDelete(string file_name
                int common_flag=0)

void FileFlush(int handle)

void FileFlush(int file_handle)

bool FileIsEnding(int handle)

bool FileIsEnding(int file_handle)

bool FileIsLineEnding(int handle)

bool FileIsLineEnding(int file_handle)

int FileOpen(string filename,
             int mode,
             int delimiter=';')

int FileOpen(string ile_name,
             int pen_flags,
             short delimiter='\t'
             uint codepage=CP_ACP)

int FileOpenHistory(string filename,
                    int mode,
                    int delimiter=';')

int FileReadArray(int handle,
                  object &array[],
                  int start,
                  int count)

uint FileReadArray(int file_handle,
                   void array[],
                   int start_item=0,
                   int items_count=WHOLE_ARRAY)

double FileReadDouble(int handle,
                      int size=DOUBLE_VALUE)

double FileReadDoubleMQL4(int handle,
                          int size=DOUBLE_VALUE)
  {
   return(FileReadDouble(handle));
  }

int FileReadInteger(int handle,
                    int size=LONG_VALUE)

int FileReadInteger(int file_handle,
                    int size=INT_VALUE)

double FileReadNumber(int handle)

double FileReadNumber(int file_handle)

string FileReadString(int handle,
                      int length=0)

string FileReadString(int file_handle,
                      int size=-1)

bool FileSeek(int handle,
              int offset,
              int origin)

bool FileSeekMQL4(long handle,
                  int offset,
                  ENUM_FILE_POSITION origin)
  {
   FileSeek(handle,offset,origin);
   return(true);
  }

int FileSize(int handle)

ulong FileSize(int file_handle)

int FileTell(int handle)

ulong FileTell(int file_handle)

int FileWrite(int handle,...)

uint FileWrite(int file_handle,...)

int FileWriteArray(int handle,
                   object array[],
                   int start,
                   int count)

int FileWriteArray(int file_handle,
                   void array[],
                   int start_item=0,
                   int items_count=WHOLE_ARRAY)

int FileWriteDouble(int handle,
                    double value,
                    int size=DOUBLE_VALUE)

uint FileWriteDouble(int file_handle,
                     double dvalue)

int FileWriteInteger(int handle,
                     int value,
                     int size=LONG_VALUE)

uint FileWriteInteger(int file_handle,
                      int ivalue,
                      int size=INT_VALUE)

int FileWriteString(int handle,
                    string value,
                    int size)

uint FileWriteString(int file_handle,
                     string svalue,
                     int size=-1)

bool GlobalVariableCheck(string name)

bool GlobalVariableCheck(string name)

bool GlobalVariableDel(string name)

bool GlobalVariableDel(string name)

double GlobalVariableGet(string name)

double GlobalVariableGet(string name)

string GlobalVariableName(int index)

string GlobalVariableName(int index)

datetime GlobalVariableSet(string name,
                           double value)

datetime GlobalVariableSet(string name,
                           double value)

bool GlobalVariableSetOnCondition(string name,
                                  double value,
                                  double check_value)

bool GlobalVariableSetOnCondition(string name,
                                  double value,
                                  double check_value)

int GlobalVariablesDeleteAll(string prefix_name=NULL)

int GlobalVariablesDeleteAll(string prefix_name=NULL
                             datetime limit_data=0)

int GlobalVariablesTotal()

int GlobalVariablesTotal()

double MathAbs(double value)

double MathAbs(double value)

double MathArccos(double x)

double MathArccos(double val)

double MathArcsin(double x)

double MathArcsin(double val)

double MathArctan(double x)

double MathArctan(double value)

double MathCeil(double x)

double MathCeil(double val)

double MathCos(double value)

double MathCos(double value)

double MathExp(double d)

double MathExp(double value)

double MathFloor(double x)

double MathFloor(double val)

double MathLog(double x)

double MathLog(double val)

double MathMax(double value1,
               double value2)

double MathMax(double value1,
               double value2)

double MathMin(double value1,
               double value2)

double MathMin(double value1,
               double value2)

double MathMod(double value1,
               double value2)

double MathMod(double value1,
               double value2)

double MathPow(double base,
               double exponent)

double MathPow(double base,
               double exponent)

int MathRand()

int MathRand()

double MathRound(double value)

double MathRound(double value)

double MathSin(double value)

double MathSin(double value)

double MathSqrt(double x)

double MathSqrt(double value)

void MathSrand(int seed)

void MathSrand(int seed)

double MathTan(double x)

double MathTan(double rad)

bool ObjectCreate(string name,
                  int type,
                  int window,
                  datetime time1,
                  double price1,
                  datetime time2=0,
                  double price2=0,
                  datetime time3=0,
                  double price3=0)

bool ObjectCreateMQL4(string name,
                      ENUM_OBJECT type,
                      int window,
                      datetime time1,
                      double price1,
                      datetime time2=0,
                      double price2=0,
                      datetime time3=0,
                      double price3=0)
  {
   return(ObjectCreate(0,name,type,window,
          time1,price1,time2,price2,time3,price3));
  }

bool ObjectDelete(string name)

bool ObjectDeleteMQL4(string name)
  {
   return(ObjectDelete(0,name));
  }

string ObjectDescription(string name)

string ObjectDescriptionMQL4(string name)
  {
   return(ObjectGetString(0,name,OBJPROP_TEXT));
  }

int ObjectFind(string name)

int ObjectFindMQL4(string name)
  {
   return(ObjectFind(0,name));
  }

double ObjectGet(string name,
                 int prop_id)

double ObjectGetMQL4(string name,
                     int index)
  {
   switch(index)
     {
      case OBJPROP_TIME1:
         return(ObjectGetInteger(0,name,OBJPROP_TIME));
      case OBJPROP_PRICE1:
         return(ObjectGetDouble(0,name,OBJPROP_PRICE));
      case OBJPROP_TIME2:
         return(ObjectGetInteger(0,name,OBJPROP_TIME,1));
      case OBJPROP_PRICE2:
         return(ObjectGetDouble(0,name,OBJPROP_PRICE,1));
      case OBJPROP_TIME3:
         return(ObjectGetInteger(0,name,OBJPROP_TIME,2));
      case OBJPROP_PRICE3:
         return(ObjectGetDouble(0,name,OBJPROP_PRICE,2));
      case OBJPROP_COLOR:
         return(ObjectGetInteger(0,name,OBJPROP_COLOR));
      case OBJPROP_STYLE:
         return(ObjectGetInteger(0,name,OBJPROP_STYLE));
      case OBJPROP_WIDTH:
         return(ObjectGetInteger(0,name,OBJPROP_WIDTH));
      case OBJPROP_BACK:
         return(ObjectGetInteger(0,name,OBJPROP_WIDTH));
      case OBJPROP_RAY:
         return(ObjectGetInteger(0,name,OBJPROP_RAY_RIGHT));
      case OBJPROP_ELLIPSE:
         return(ObjectGetInteger(0,name,OBJPROP_ELLIPSE));
      case OBJPROP_SCALE:
         return(ObjectGetDouble(0,name,OBJPROP_SCALE));
      case OBJPROP_ANGLE:
         return(ObjectGetDouble(0,name,OBJPROP_ANGLE));
      case OBJPROP_ARROWCODE:
         return(ObjectGetInteger(0,name,OBJPROP_ARROWCODE));
      case OBJPROP_TIMEFRAMES:
         return(ObjectGetInteger(0,name,OBJPROP_TIMEFRAMES));
      case OBJPROP_DEVIATION:
         return(ObjectGetDouble(0,name,OBJPROP_DEVIATION));
      case OBJPROP_FONTSIZE:
         return(ObjectGetInteger(0,name,OBJPROP_FONTSIZE));
      case OBJPROP_CORNER:
         return(ObjectGetInteger(0,name,OBJPROP_CORNER));
      case OBJPROP_XDISTANCE:
         return(ObjectGetInteger(0,name,OBJPROP_XDISTANCE));
      case OBJPROP_YDISTANCE:
         return(ObjectGetInteger(0,name,OBJPROP_YDISTANCE));
      case OBJPROP_FIBOLEVELS:
         return(ObjectGetInteger(0,name,OBJPROP_LEVELS));
      case OBJPROP_LEVELCOLOR:
         return(ObjectGetInteger(0,name,OBJPROP_LEVELCOLOR));
      case OBJPROP_LEVELSTYLE:
         return(ObjectGetInteger(0,name,OBJPROP_LEVELSTYLE));
      case OBJPROP_LEVELWIDTH:
         return(ObjectGetInteger(0,name,OBJPROP_LEVELWIDTH));
     }
  }

string ObjectGetFiboDescriptionMQL4(string name,
                                    int index)
  {
   return(ObjectGetString(0,name,OBJPROP_LEVELTEXT,index));
  }

int ObjectGetShiftByValue(string name,
                          double value)

int ObjectGetShiftByValueMQL4(string name,
                              double value)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(PERIOD_CURRENT);
   datetime Arr[];
   int shift;
   MqlRates mql4[];
   if(ObjectGetTimeByValue(0,name,value)<0) return(-1);
   CopyRates(NULL,timeframe,0,1,mql4);
   if(CopyTime(NULL,timeframe,mql4[0].time,
      ObjectGetTimeByValue(0,name,value),Arr)>0)
      return(ArraySize(Arr)-1);
   else return(-1);
  }

double ObjectGetValueByShift(string name,
                             int shift)

double ObjectGetValueByShiftMQL4(string name,
                                 int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(PERIOD_CURRENT);
   MqlRates mql4[];
   CopyRates(NULL,timeframe,shift,1,mql4);
   return(ObjectGetValueByTime(0,name,mql4[0].time,0));
  }

bool ObjectMove(string name,
                int point,
                datetime time1,
                double price1)

bool ObjectMoveMQL4(string name,
                    int point,
                    datetime time1,
                    double price1)
  {
   return(ObjectMove(0,name,point,time1,price1));
  }

string ObjectName(int index)

string ObjectNameMQL4(int index)
  {
   return(ObjectName(0,index));
  }

int ObjectsDeleteAll(int window=EMPTY,
                     int type=EMPTY)

int ObjectsDeleteAllMQL4(int window=EMPTY,
                         int type=EMPTY)
  {
   return(ObjectsDeleteAll(0,window,type));
  }

bool ObjectSet(string name,
               int prop_id,
               double value)

bool ObjectSetMQL4(string name,
                   int index,
                   double value)
  {
   switch(index)
     {
      case OBJPROP_TIME1:
         ObjectSetInteger(0,name,OBJPROP_TIME,(int)value);return(true);
      case OBJPROP_PRICE1:
         ObjectSetDouble(0,name,OBJPROP_PRICE,value);return(true);
      case OBJPROP_TIME2:
         ObjectSetInteger(0,name,OBJPROP_TIME,1,(int)value);return(true);
      case OBJPROP_PRICE2:
         ObjectSetDouble(0,name,OBJPROP_PRICE,1,value);return(true);
      case OBJPROP_TIME3:
         ObjectSetInteger(0,name,OBJPROP_TIME,2,(int)value);return(true);
      case OBJPROP_PRICE3:
         ObjectSetDouble(0,name,OBJPROP_PRICE,2,value);return(true);
      case OBJPROP_COLOR:
         ObjectSetInteger(0,name,OBJPROP_COLOR,(int)value);return(true);
      case OBJPROP_STYLE:
         ObjectSetInteger(0,name,OBJPROP_STYLE,(int)value);return(true);
      case OBJPROP_WIDTH:
         ObjectSetInteger(0,name,OBJPROP_WIDTH,(int)value);return(true);
      case OBJPROP_BACK:
         ObjectSetInteger(0,name,OBJPROP_BACK,(int)value);return(true);
      case OBJPROP_RAY:
         ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,(int)value);return(true);
      case OBJPROP_ELLIPSE:
         ObjectSetInteger(0,name,OBJPROP_ELLIPSE,(int)value);return(true);
      case OBJPROP_SCALE:
         ObjectSetDouble(0,name,OBJPROP_SCALE,value);return(true);
      case OBJPROP_ANGLE:
         ObjectSetDouble(0,name,OBJPROP_ANGLE,value);return(true);
      case OBJPROP_ARROWCODE:
         ObjectSetInteger(0,name,OBJPROP_ARROWCODE,(int)value);return(true);
      case OBJPROP_TIMEFRAMES:
         ObjectSetInteger(0,name,OBJPROP_TIMEFRAMES,(int)value);return(true);
      case OBJPROP_DEVIATION:
         ObjectSetDouble(0,name,OBJPROP_DEVIATION,value);return(true);
      case OBJPROP_FONTSIZE:
         ObjectSetInteger(0,name,OBJPROP_FONTSIZE,(int)value);return(true);
      case OBJPROP_CORNER:
         ObjectSetInteger(0,name,OBJPROP_CORNER,(int)value);return(true);
      case OBJPROP_XDISTANCE:
         ObjectSetInteger(0,name,OBJPROP_XDISTANCE,(int)value);return(true);
      case OBJPROP_YDISTANCE:
         ObjectSetInteger(0,name,OBJPROP_YDISTANCE,(int)value);return(true);
      case OBJPROP_FIBOLEVELS:
         ObjectSetInteger(0,name,OBJPROP_LEVELS,(int)value);return(true);
      case OBJPROP_LEVELCOLOR:
         ObjectSetInteger(0,name,OBJPROP_LEVELCOLOR,(int)value);return(true);
      case OBJPROP_LEVELSTYLE:
         ObjectSetInteger(0,name,OBJPROP_LEVELSTYLE,(int)value);return(true);
      case OBJPROP_LEVELWIDTH:
         ObjectSetInteger(0,name,OBJPROP_LEVELWIDTH,(int)value);return(true);

      default: return(false);
     }
   return(false);
  }

bool ObjectSetFiboDescription(string name,
                              int index,
                              string text)

bool ObjectSetFiboDescriptionMQL4(string name,
                                  int index,
                                  string text)
  {
   return(ObjectSetString(0,name,OBJPROP_LEVELTEXT,index,text));
  }

bool ObjectSetText(string name,
                   string text,
                   int font_size,
                   string font_name=NULL,
                   color text_color=CLR_NONE)

bool ObjectSetTextMQL4(string name,
                       string text,
                       int font_size,
                       string font="",
                       color text_color=CLR_NONE)
  {
   int tmpObjType=(int)ObjectGetInteger(0,name,OBJPROP_TYPE);
   if(tmpObjType!=OBJ_LABEL && tmpObjType!=OBJ_TEXT) return(false);
   if(StringLen(text)>0 && font_size>0)
     {
      if(ObjectSetString(0,name,OBJPROP_TEXT,text)==true
         && ObjectSetInteger(0,name,OBJPROP_FONTSIZE,font_size)==true)
        {
         if((StringLen(font)>0)
            && ObjectSetString(0,name,OBJPROP_FONT,font)==false)
            return(false);
         if(text_color>-1
            && ObjectSetInteger(0,name,OBJPROP_COLOR,text_color)==false)
            return(false);
         return(true);
        }
      return(false);
     }
   return(false);
  }

int ObjectsTotal(int type=EMPTY)

int ObjectsTotalMQL4(int type=EMPTY,
                     int window=-1)
  {
   return(ObjectsTotal(0,window,type));
  }

int ObjectType(string name)

int ObjectTypeMQL4(string name)
  {
   return((int)ObjectGetInteger(0,name,OBJPROP_TYPE));
  }

string StringConcatenate(...)

int StringConcatenate(string &string_var,
                      void argument1
                      void argument2
                      ...)

int StringFind(string text,
               string matched_text,
               int start=0)

int StringFind(string string_value,
               string match_substring,
               int start_pos=0)

int StringGetChar(string text,
                  int pos)

ushort StringGetCharacter(string string_value,
                          int pos)

int StringLen(string text)

int StringLen(string string_value)

string StringSetChar(string text,
                     int pos,
                     int value)

bool StringSetCharacter(string &string_var,
                        int pos,
                        ushort character)

string StringSubstr(string text,
                    int start,
                    int length=0)

string StringSubstr(string string_value,
                    int start_pos,
                    int length=-1)

string StringTrimLeft(string text)

int StringTrimLeft(string& string_var)

string StringTrimRight(string text)

int StringTrimRight(string& string_var)

double iAC(string symbol,
           int timeframe,
           int shift)

double iACMQL4(string symbol,
               int tf,
               int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iAC(symbol,timeframe);
   if(handle<0)
     {
      Print("Объект iAC не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iAD(string symbol,
           int timeframe,
           int shift)

double iADMQL4(string symbol,
               int tf,
               int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=(int)iAD(symbol,timeframe,VOLUME_TICK);
   if(handle<0)
     {
      Print("Объект iAD не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iAlligator(string symbol,
                  int timeframe,
                  int jaw_period,
                  int jaw_shift,
                  int teeth_period,
                  int teeth_shift,
                  int lips_period,
                  int lips_shift,
                  int ma_method,
                  int applied_price,
                  int mode,
                  int shift)

double iAlligatorMQL4(string symbol,
                      int tf,
                      int jaw_period,
                      int jaw_shift,
                      int teeth_period,
                      int teeth_shift,
                      int lips_period,
                      int lips_shift,
                      int method,
                      int price,
                      int mode,
                      int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iAlligator(symbol,timeframe,jaw_period,jaw_shift,
                         teeth_period,teeth_shift,
                         lips_period,lips_shift,
                         ma_method,applied_price);
   if(handle<0)
     {
      Print("Объект iAlligator не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode-1,shift));
  }

double iADX(string symbol,
            int timeframe,
            int period,
            int applied_price,
            int mode,
            int shift)

double iADXMQL4(string symbol,
                int tf,
                int period,
                int price,
                int mode,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iADX(symbol,timeframe,period);
   if(handle<0)
     {
      Print("Объект iADX не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode,shift));
  }

double iATR(string symbol,
            int timeframe,
            int period,
            int shift)

double iATRMQL4(string symbol,
                int tf,
                int period,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iATR(symbol,timeframe,period);
   if(handle<0)
     {
      Print("Объект iATR не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iAO(string symbol,
           int timeframe,
           int shift)

double iAOMQL4(string symbol,
               int tf,
               int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iAO(symbol,timeframe);
   if(handle<0)
     {
      Print("Объект iAO не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iBearsPower(string symbol,
                   int timeframe,
                   int period,
                   int applied_price,
                   int shift)

double iBearsPowerMQL4(string symbol,
                       int tf,
                       int period,
                       int price,
                       int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iBearsPower(symbol,timeframe,period);
   if(handle<0)
     {
      Print("Объект iBearsPower не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iBands(string symbol,
              int timeframe,
              int period,
              int deviation,
              int bands_shift,
              int applied_price,
              int mode,
              int shift)

double iBandsMQL4(string symbol,
                  int tf,
                  int period,
                  double deviation,
                  int bands_shift,
                  int method,
                  int mode,
                  int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   int handle=iBands(symbol,timeframe,period,
                     bands_shift,deviation,ma_method);
   if(handle<0)
     {
      Print("Объект iBands не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode,shift));
  }

double iBandsOnArray(double array[],
                     int total,
                     int period,
                     int deviation,
                     int bands_shift,
                     int mode,
                     int shift)

double iBullsPower(string symbol,
                   int timeframe,
                   int period,
                   int applied_price,
                   int shift)

double iBullsPowerMQL4(string symbol,
                       int tf,
                       int period,
                       int price,
                       int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iBullsPower(symbol,timeframe,period);
   if(handle<0)
     {
      Print("Объект iBullsPower не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iCCI(string symbol,
            int timeframe,
            int period,
            int applied_price,
            int shift)

double iCCIMQL4(string symbol,
                int tf,
                int period,
                int price,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iCCI(symbol,timeframe,period,price);
   if(handle<0)
     {
      Print("Объект iCCI не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iCCIOnArray(double array[],
                   int total,
                   int period,
                   int shift)

double iCustom(string symbol,
               int timeframe,
               string name,
               ...,
               int mode,
               int shift)

int iCustom(string symbol,
            ENUM_TIMEFRAMES period,
            string name
            ...)

double iDeMarker(string symbol,
                 int timeframe,
                 int period,
                 int shift)

double iDeMarkerMQL4(string symbol,
                     int tf,
                     int period,
                     int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iDeMarker(symbol,timeframe,period);
   if(handle<0)
     {
      Print("Объект iDeMarker не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iEnvelopes(string symbol,
                  int timeframe,
                  int ma_period,
                  int ma_method,
                  int ma_shift,
                  int applied_price,
                  double deviation,
                  int mode,
                  int shift)

double EnvelopesMQL4(string symbol,
                     int tf,
                     int ma_period,
                     int method,
                     int ma_shift,
                     int price,
                     double deviation,
                     int mode,
                     int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iEnvelopes(symbol,timeframe,
                         ma_period,ma_shift,ma_method,
                         applied_price,deviation);
   if(handle<0)
     {
      Print("Объект iEnvelopes не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode-1,shift));
  }

double iEnvelopesOnArray(double array[],
                         int total,
                         int ma_period,
                         int ma_method,
                         int ma_shift,
                         double deviation,
                         int mode,
                         int shift)

double iForce(string symbol,
              int timeframe,
              int period,
              int ma_method,
              int applied_price,
              int shift)

double iForceMQL4(string symbol,
                  int tf,
                  int period,
                  int method,
                  int price,
                  int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   int handle=iForce(symbol,timeframe,period,ma_method,VOLUME_TICK);
   if(handle<0)
     {
      Print("Объект iForce не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iFractals(string symbol,
                 int timeframe,
                 int mode,
                 int shift)

double iFractalsMQL4(string symbol,
                     int tf,
                     int mode,
                     int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iFractals(symbol,timeframe);
   if(handle<0)
     {
      Print("Объект iFractals не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode-1,shift));
  }

double iGator(string symbol,
              int timeframe,
              int jaw_period,
              int jaw_shift,
              int teeth_period,
              int teeth_shift,
              int lips_period,
              int lips_shift,
              int ma_method,
              int applied_price,
              int mode,
              int shift)

double iGatorMQL4(string symbol,
                  int tf,
                  int jaw_period,
                  int jaw_shift,
                  int teeth_period,
                  int teeth_shift,
                  int lips_period,
                  int lips_shift,
                  int method,
                  int price,
                  int mode,
                  int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iGator(symbol,timeframe,jaw_period,jaw_shift,
                     teeth_period,teeth_shift,
                     lips_period,lips_shift,
                     ma_method,applied_price);
   if(handle<0)
     {
      Print("Объект iGator не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode-1,shift));
  }

double iIchimoku(string symbol,
                 int timeframe,
                 int tenkan_sen,
                 int kijun_sen,
                 int senkou_span_b,
                 int mode,
                 int shift)

double iIchimokuMQL4(string symbol,
                     int tf,
                     int tenkan_sen,
                     int kijun_sen,
                     int senkou_span_b,
                     int mode,
                     int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iIchimoku(symbol,timeframe,
                        tenkan_sen,kijun_sen,senkou_span_b);
   if(handle<0)
     {
      Print("Объект iIchimoku не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode-1,shift));
  }

double iBWMFI(string symbol,
              int timeframe,
              int shift)

double iBWMFIMQL4(string symbol,
                  int tf,
                  int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=(int)iBWMFI(symbol,timeframe,VOLUME_TICK);
   if(handle<0)
     {
      Print("Объект iBWMFI не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iMomentum(string symbol,
                 int timeframe,
                 int period,
                 int applied_price,
                 int shift)

double iMomentumMQL4(string symbol,
                     int tf,
                     int period,
                     int price,
                     int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iMomentum(symbol,timeframe,period,applied_price);
   if(handle<0)
     {
      Print("Объект iMomentum не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iMomentumOnArray(double array[],
                        int total,
                        int period,
                        int shift)

double iMFI(string symbol,
            int timeframe,
            int period,
            int shift)

double iMFIMQL4(string symbol,
                int tf,
                int period,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=(int)iMFI(symbol,timeframe,period,VOLUME_TICK);
   if(handle<0)
     {
      Print("Объект iMFI не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iMA(string symbol,
           int timeframe,
           int period,
           int ma_shift,
           int ma_method,
           int applied_price,
           int shift)

double iMAMQL4(string symbol,
               int tf,
               int period,
               int ma_shift,
               int method,
               int price,
               int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iMA(symbol,timeframe,period,ma_shift,
                  ma_method,applied_price);
   if(handle<0)
     {
      Print("Объект iMA не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iMAOnArray(double array[],
                  int total,
                  int period,
                  int ma_shift,
                  int ma_method,
                  int shift)

double iOsMA(string symbol,
             int timeframe,
             int fast_ema_period,
             int slow_ema_period,
             int signal_period,
             int applied_price,
             int shift)

double iOsMAMQL4(string symbol,
                 int tf,
                 int fast_ema_period,
                 int slow_ema_period,
                 int signal_period,
                 int price,
                 int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iOsMA(symbol,timeframe,
                    fast_ema_period,slow_ema_period,
                    signal_period,applied_price);
   if(handle<0)
     {
      Print("Объект iOsMA не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iMACD(string symbol,
             int timeframe,
             int fast_ema_period,
             int slow_ema_period,
             int signal_period,
             int applied_price,
             int mode,
             int shift)

double iMACDMQL4(string symbol,
                 int tf,
                 int fast_ema_period,
                 int slow_ema_period,
                 int signal_period,
                 int price,
                 int mode,
                 int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iMACD(symbol,timeframe,
                    fast_ema_period,slow_ema_period,
                    signal_period,applied_price);
   if(handle<0)
     {
      Print("Объект iMACD не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode,shift));
  }

double iOBV(string symbol,
            int timeframe,
            int applied_price,
            int shift)

double iOBVMQL4(string symbol,
                int tf,
                int price,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iOBV(symbol,timeframe,VOLUME_TICK);
   if(handle<0)
     {
      Print("Объект iOBV не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iSAR(string symbol,
            int timeframe,
            double step,
            double maximum,
            int shift)

double iSARMQL4(string symbol,
                int tf,
                double step,
                double maximum,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iSAR(symbol,timeframe,step,maximum);
   if(handle<0)
     {
      Print("Объект iSAR не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iRSI(string symbol,
            int timeframe,
            int period,
            int applied_price,
            int shift)

double iRSIMQL4(string symbol,
                int tf,
                int period,
                int price,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iRSI(symbol,timeframe,period,applied_price);
   if(handle<0)
     {
      Print("Объект iRSI не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iRSIOnArray(double array[],
                   int total,
                   int period,
                   int shift)

double iRVI(string symbol,
            int timeframe,
            int period,
            int mode,
            int shift)

double iRVIMQL4(string symbol,
                int tf,
                int period,
                int mode,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iRVI(symbol,timeframe,period);
   if(handle<0)
     {
      Print("Объект iRVI не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode,shift));
  }

double iStdDev(string symbol,
               int timeframe,
               int ma_period,
               int ma_shift,
               int ma_method,
               int applied_price,
               int shift)

double iStdDevMQL4(string symbol,
                   int tf,
                   int ma_period,
                   int ma_shift,
                   int method,
                   int price,
                   int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   ENUM_APPLIED_PRICE applied_price=PriceMigrate(price);
   int handle=iStdDev(symbol,timeframe,ma_period,ma_shift,
                      ma_method,applied_price);
   if(handle<0)
     {
      Print("Объект iStdDev не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

double iStdDevOnArray(double array[],
                      int total,
                      int ma_period,
                      int ma_shift,
                      int ma_method,
                      int shift)

double iStochastic(string symbol,
                   int timeframe,
                   int%Kperiod,
                   int%Dperiod,
                   int slowing,
                   int method,
                   int price_field,
                   int mode,
                   int shift)

double iStochasticMQL4(string symbol,
                       int tf,
                       int Kperiod,
                       int Dperiod,
                       int slowing,
                       int method,
                       int field,
                       int mode,
                       int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   ENUM_MA_METHOD ma_method=MethodMigrate(method);
   ENUM_STO_PRICE price_field=StoFieldMigrate(field);
   int handle=iStochastic(symbol,timeframe,Kperiod,Dperiod,
                          slowing,ma_method,price_field);
   if(handle<0)
     {
      Print("Объект iStochastic не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,mode,shift));
  }

double iWPR(string symbol,
            int timeframe,
            int period,
            int shift)

double iWPRMQL4(string symbol,
                int tf,
                int period,
                int shift)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   int handle=iWPR(symbol,timeframe,period);
   if(handle<0)
     {
      Print("Объект iWPR не создан: Ошибка ",GetLastError());
      return(-1);
     }
   else
      return(CopyBufferMQL4(handle,0,shift));
  }

int iBars(string symbol,
          int timeframe)

int iBarsMQL4(string symbol,int tf)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   return(Bars(symbol,timeframe));
  }

int iBarShift(string symbol,
              int timeframe,
              datetime time,
              bool exact=false)

int iBarShiftMQL4(string symbol,
                  int tf,
                  datetime time,
                  bool exact=false)
  {
   if(time<0) return(-1);
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   datetime Arr[],time1;
   CopyTime(symbol,timeframe,0,1,Arr);
   time1=Arr[0];
   if(CopyTime(symbol,timeframe,time,time1,Arr)>0)
     {
      if(ArraySize(Arr)>2) return(ArraySize(Arr)-1);
      if(time<time1) return(1);
      else return(0);
     }
   else return(-1);
  }

double iClose(string symbol,
              int timeframe,
              int shift)

double iCloseMQL4(string symbol,int tf,int index)
{
   if(index < 0) return(-1);
   double Arr[];
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   if(CopyClose(symbol,timeframe, index, 1, Arr)>0) 
        return(Arr[0]);
   else return(-1);
}

double iHigh(string symbol,
             int timeframe,
             int shift)

double iHighMQL4(string symbol,int tf,int index)
{
   if(index < 0) return(-1);
   double Arr[];
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   if(CopyHigh(symbol,timeframe, index, 1, Arr)>0) 
        return(Arr[0]);
   else return(-1);
}

int iHighest(string symbol,
             int timeframe,
             int type,
             int count=WHOLE_ARRAY,
             int start=0)

int iHighestMQL4(string symbol,
                 int tf,
                 int type,
                 int count=WHOLE_ARRAY,
                 int start=0)
  {
   if(start<0) return(-1);
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   if(count<=0) count=Bars(symbol,timeframe);
   if(type<=MODE_OPEN)
     {
      double Open[];
      ArraySetAsSeries(Open,true);
      CopyOpen(symbol,timeframe,start,count,Open);
      return(ArrayMaximum(Open,0,count)+start);
     }
   if(type==MODE_LOW)
     {
      double Low[];
      ArraySetAsSeries(Low,true);
      CopyLow(symbol,timeframe,start,count,Low);
      return(ArrayMaximum(Low,0,count)+start);
     }
   if(type==MODE_HIGH)
     {
      double High[];
      ArraySetAsSeries(High,true);
      CopyHigh(symbol,timeframe,start,count,High);
      return(ArrayMaximum(High,0,count)+start);
     }
   if(type==MODE_CLOSE)
     {
      double Close[];
      ArraySetAsSeries(Close,true);
      CopyClose(symbol,timeframe,start,count,Close);
      return(ArrayMaximum(Close,0,count)+start);
     }
   if(type==MODE_VOLUME)
     {
      long Volume[];
      ArraySetAsSeries(Volume,true);
      CopyTickVolume(symbol,timeframe,start,count,Volume);
      return(ArrayMaximum(Volume,0,count)+start);
     }
   if(type>=MODE_TIME)
     {
      datetime Time[];
      ArraySetAsSeries(Time,true);
      CopyTime(symbol,timeframe,start,count,Time);
      return(ArrayMaximum(Time,0,count)+start);
      //---
     }
   return(0);
  }

double iLow(string symbol,
            int timeframe,
            int shift)

double iLowMQL4(string symbol,int tf,int index)
{
   if(index < 0) return(-1);
   double Arr[];
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   if(CopyLow(symbol,timeframe, index, 1, Arr)>0)
        return(Arr[0]);
   else return(-1);
}

int iLowest(string symbol,
            int timeframe,
            int type,
            int count=WHOLE_ARRAY,
            int start=0)

int iLowestMQL4(string symbol,
                int tf,
                int type,
                int count=WHOLE_ARRAY,
                int start=0)
  {
   if(start<0) return(-1);
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   if(count<=0) count=Bars(symbol,timeframe);
   if(type<=MODE_OPEN)
     {
      double Open[];
      ArraySetAsSeries(Open,true);
      CopyOpen(symbol,timeframe,start,count,Open);
      return(ArrayMinimum(Open,0,count)+start);
     }
   if(type==MODE_LOW)
     {
      double Low[];
      ArraySetAsSeries(Low,true);
      CopyLow(symbol,timeframe,start,count,Low);
      return(ArrayMinimum(Low,0,count)+start);
     }
   if(type==MODE_HIGH)
     {
      double High[];
      ArraySetAsSeries(High,true);
      CopyHigh(symbol,timeframe,start,count,High);
      return(ArrayMinimum(High,0,count)+start);
     }
   if(type==MODE_CLOSE)
     {
      double Close[];
      ArraySetAsSeries(Close,true);
      CopyClose(symbol,timeframe,start,count,Close);
      return(ArrayMinimum(Close,0,count)+start);
     }
   if(type==MODE_VOLUME)
     {
      long Volume[];
      ArraySetAsSeries(Volume,true);
      CopyTickVolume(symbol,timeframe,start,count,Volume);
      return(ArrayMinimum(Volume,0,count)+start);
     }
   if(type>=MODE_TIME)
     {
      datetime Time[];
      ArraySetAsSeries(Time,true);
      CopyTime(symbol,timeframe,start,count,Time);
      return(ArrayMinimum(Time,0,count)+start);
     }
//---
   return(0);
  }

double iOpen(string symbol,
             int timeframe,
             int shift)

double iOpenMQL4(string symbol,int tf,int index)
{   
   if(index < 0) return(-1);
   double Arr[];
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   if(CopyOpen(symbol,timeframe, index, 1, Arr)>0) 
        return(Arr[0]);
   else return(-1);
}

datetime iTime(string symbol,
               int timeframe,
               int shift)

datetime iTimeMQL4(string symbol,int tf,int index)
{
   if(index < 0) return(-1);
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   datetime Arr[];
   if(CopyTime(symbol, timeframe, index, 1, Arr)>0)
        return(Arr[0]);
   else return(-1);
}

double iVolume(string symbol,
               int timeframe,
               int shift)

int iVolumeMQL4(string symbol,int tf,int index)
{
   if(index < 0) return(-1);
   long Arr[];
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   if(CopyTickVolume(symbol, timeframe, index, 1, Arr)>0)
        return(Arr[0]);
   else return(-1);
}

void HideTestIndicators(bool hide)

int Period()

ENUM_TIMEFRAMES  Period()

bool RefreshRates()

string Symbol()

string Symbol()

int WindowBarsPerChart()

int ChartGetInteger(0,CHART_VISIBLE_BARS,0)

string WindowExpertName()

string MQLInfoString(MQL5_PROGRAM_NAME)

int WindowFind(string name)

int WindowFindMQL4(string name)
  {
   int window=-1;
   if((ENUM_PROGRAM_TYPE)MQLInfoInteger(MQL5_PROGRAM_TYPE)==PROGRAM_INDICATOR)
     {
      window=ChartWindowFind();
     }
   else
     {
      window=ChartWindowFind(0,name);
      if(window==-1) Print(__FUNCTION__+"(): Error = ",GetLastError());
     }
   return(window);
  }

int WindowFirstVisibleBar()

int ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0)

int WindowHandle(string symbol,
                 int timeframe)

int WindowHandleMQL4(string symbol,
                     int tf)
  {
   ENUM_TIMEFRAMES timeframe=TFMigrate(tf);
   long currChart,prevChart=ChartFirst();
   int i=0,limit=100;
   while(i<limit)
     {
      currChart=ChartNext(prevChart);
      if(currChart<0) break;
      if(ChartSymbol(currChart)==symbol
         && ChartPeriod(currChart)==timeframe)
         return((int)currChart);
      prevChart=currChart;
      i++;
     }
   return(0);
  }

bool WindowIsVisible(int index)

bool ChartGetInteger(0,CHART_WINDOW_IS_VISIBLE,index)

int WindowOnDropped()

int ChartWindowOnDropped()

double WindowPriceMax(int index=0)

double ChartGetDouble(0,CHART_PRICE_MAX,index)

double WindowPriceMin(int index=0)

double ChartGetDouble(0,CHART_PRICE_MIN,index)

double WindowPriceOnDropped()

double ChartPriceOnDropped()

void WindowRedraw()

void ChartRedraw(0)

bool WindowScreenShot(string filename,
                      int size_x,
                      int size_y,
                      int start_bar=-1,
                      int chart_scale=-1,
                      int chart_mode=-1)

bool WindowScreenShotMQL4(string filename,
                          int size_x,
                          int size_y,
                          int start_bar=-1,
                          int chart_scale=-1,
                          int chart_mode=-1)
  {
   if(chart_scale>0 && chart_scale<=5)
      ChartSetInteger(0,CHART_SCALE,chart_scale);
   switch(chart_mode)
     {
      case 0: ChartSetInteger(0,CHART_MODE,CHART_BARS);
      case 1: ChartSetInteger(0,CHART_MODE,CHART_CANDLES);
      case 2: ChartSetInteger(0,CHART_MODE,CHART_LINE);
     }
   if(start_bar<0)
      return(ChartScreenShot(0,filename,size_x,size_y,ALIGN_RIGHT));
   else
      return(ChartScreenShot(0,filename,size_x,size_y,ALIGN_LEFT));
  }

datetime WindowTimeOnDropped()

datetime ChartTimeOnDropped()

int WindowsTotal()

int ChartGetInteger(0,CHART_WINDOWS_TOTAL)

int WindowXOnDropped()

int ChartXOnDropped()

int WindowYOnDropped()

int ChartYOnDropped()