#property copyright "  * * * Lucifer * * *  "
#property link      ""

#import "kernel32.dll"
   int CreateFileW(string lpFileName, int dwDesiredAccess, int dwShareMode, int lpSecurityAttributes, int dwCreationDisposition, int dwFlagsAndAttributes, int hTemplateFile);
   int GetFileSize(int hFile, int& lpFileSizeHigh[]);
   int ReadFile(int hFile, int &lpBuffer[], int nNumberOfBytesToRead, int &lpNumberOfBytesRead[], int lpOverlapped);
   int DeleteFileW(string lpFileName);
   int WriteFile(int hFile, int &lpBuffer[], int nNumberOfBytesToWrite, int& lpNumberOfBytesWritten, int lpOverlappe);
   int _llseek(int handle,int offset,int origin);
   int CloseHandle(int hObject);
   int CreateDirectoryW(string path, int lpSecurityAttributes);
#import


extern string mv="метод передачи сигналов: 1-разные терминалы (Kernel32.DLL); / 0-один терминал с двумя вкладками";
extern int TRANCEFER=0;
//------------------------------------------------------------------------------------------
extern string mp="спред: 1-Фиксированный / 0-авто-определение";
extern int SPREAD_CONST=0;
//------------------------------------------------------------------------------------------
extern string m9="режим: 0=запись, 1=торговля, 2=торговля+запись";
extern int MWORK=2;
//------------------------------------------------------------------------------------------
extern string tl="время: 1- локальное / 0- с сервера";
extern int USE_LOCAL_TIME=1;
//------------------------------------------------------------------------------------------
extern string mo="путь к сигналам";
extern string DATA_PATH="C:\\q_Signals";
//------------------------------------------------------------------------------------------
extern string ma="использовать MAGIC NUMBER: >0-ДА / 0-НЕТ";
extern int MAGIC_NUMBER=777;




static bool no_worked, Agree, MATCH_LIMIT_ORDERS, FREE[3000], WAIT[3000], ORIGIN;
static string s2, s3, s5;
static int Direction[500], PIP[], PIP2[], TRADE_SHIFT_LIM, RISE_VECTOR, Digits_now, MG_ZOOM, MMM0[500];
static int PERCENT_OF_CUT, TICKS_ALL, ORDERLIFE_LIM, ORDERLIFE, MOI, MD[3000], RISE_PIPS2;
static double MS[3000], askprev, bidprev, hand_point, PLANCA, DAY_MIN, DAY_MAX, PREV[6];
static datetime MDL[3000], PL_UP, PL_DN, TEST_SECOND, WAITING, LOGGING, TAK;
static int TRADE_SHIFT_ON_STOP, ORDERLIFE_ON_TURN_STOP, TRADE_SHIFT_REV;
static int q1, q2, q3;
static int RID[4];
static int Treasure, ND, MAX_TPS, MIN_TPS, LOSS_INSPECTION;
static bool First_Time, TPS_Agree, TPS_Agree2, DELETE_PENDINGS_ORDERS, First_Time2, AG_DEPTH, already_reported;
static int MAX_LOSS, TRADE_SHIFT, CHANNEL_OLD2;
static int MAX_POINT, CHECK_SECOND;
static int LIVES_UP, LIVES_DN, LEVEL, FOUND, TICKER;
static int SMART_PROFIT_SELECT, TRADE_CONTROL, IMPULSE_WAIT, ORDERLIFE_REV, CRUSER_MODE, bytesread[1], lo[1], IOS;


static double DAT[];

void init()
  {
  int q, j, z, r=0, de;
  string ASCII[4], file_of_lag, st;
  datetime ttl;
                                                                                                                                                                                       ASCII[1]="о"; ASCII[2]="г"; ASCII[3]="Ь";
  if (MAGIC_NUMBER>0) s5=DoubleToStr(MAGIC_NUMBER,0)+"_"; else s5="";
  st="TRADE_START_GLOBAL"; if (!GlobalVariableCheck(st)) GlobalVariableSet(st, 0);
  r=3;
  for (z=1; z<4; z++) {r--; if (z==3) r=2; RID[z]=StringGetChar(ASCII[z],0)/r;}
  RID[0]=RID[r]-(RID[1]+RID[3]);
  z=300; r=-1; while (r<61 && z>0) {r=ArrayResize(DAT,61); z--;}
  ArrayInitialize(DAT, -1000);
  no_worked=false;
  ORIGIN=false;
  First_Time2=true;
  s2=Symbol();
  DATA_PATH=DATA_PATH+CharToStr(92)+CharToStr(92);
  if (TRANCEFER==1)
  {
  j=CreateFileW(DATA_PATH+"test", FILE_BIN|FILE_READ|FILE_WRITE, 1, 0, 4, 32, 2);
  if (j>-1)
     {
     CloseHandle(j);
     DeleteFileW(DATA_PATH+"test");
     Print("нет необходимости создавать каталоги: "+DATA_PATH);
     }
     else
     {
     Print("первый раз создаём путь для общения Receiver и Exporter - может зависнуть");
     q=StringLen(DATA_PATH)+1;
     for (j=1; j<q; j++)
         {
         if (StringSubstr(DATA_PATH, j, 1)==CharToStr(92))
            {
            st=StringSubstr(DATA_PATH, 0, j);
            if (StringSubstr(DATA_PATH, j-1, 1)!=CharToStr(58)) CreateDirectoryW(st, 0);
            if (StringSubstr(DATA_PATH, j, 1)==CharToStr(92)) j++;
            }}}}
  ttl=TimeLocal();
  Treasure=TimeHour(ttl)+TimeDay(ttl)+TimeMinute(ttl)+TimeSeconds(ttl)+TimeMonth(ttl);
  z=StringLen(s2);
  if (z>6) s3=StringSubstr(s2, 0, 6); else s3=s2;
if (TRANCEFER==1 && MWORK>0 && ORIGIN)
   {
   j=CreateFileW(DATA_PATH+"alo.txt", FILE_BIN|FILE_READ|FILE_WRITE, 1, 0, 4, 32, 2);
   if (j>-1) CloseHandle(j);}
   if (MWORK!=0)
   {
   file_of_lag="q_result_"+s3+".lag";
   q=FileOpen(file_of_lag, FILE_BIN|FILE_READ);
   if (q!=-1){
      z=200; j=-1; while (j!=60 && z>0) {j=FileReadArray(q, DAT, 1, 60); z--;}
      if (FileSize(q)>480) TEST_SECOND=FileReadInteger(q, LONG_VALUE); else TEST_SECOND=0;
      FileClose(q);
      z=DAT[42];
      if (z==11 || z==12) DELETE_PENDINGS_ORDERS=false; else DELETE_PENDINGS_ORDERS=true;
      DAT[42]=DELETE_PENDINGS_ORDERS;
      if (j==60)
         {
         if (TRANCEFER==0)
            {
            GlobalVariableSet(s5+"z_"+s3+"_txt",-1);
            GlobalVariableSet(s5+"z_"+s3+"_ans",-1);
            GlobalVariableSet(s5+"z_"+s3+"_crc",-1);}
            Print ("найден Чистовик (Found Origin)");
            if (TEST_SECOND>0) Print ("дата создания чистовика тестером: "+TimeToStr(TEST_SECOND,TIME_DATE|TIME_MINUTES|TIME_SECONDS));
            StartRetreive();
            ORIGIN=true;}}


  if (!ORIGIN)
     {
     Print("Чистовик не найден - робот торговать не будет");
     if (MWORK==1) return; else no_worked=true;
     }







        if (DAT[27]>DAT[28])
           {
           de=DAT[28];
           DAT[28]=DAT[27];
           DAT[27]=de;
           }





  Print ("");
  z=300; r=-1; while (r!=TICKS_ALL+1 && z>0) {r=ArrayResize(PIP, TICKS_ALL+1); z--;}
  z=300; r=-1; while (r!=TRADE_SHIFT_ON_STOP+1 && z>0) {r=ArrayResize(PIP2, TRADE_SHIFT_ON_STOP+1); z--;}
  Agree=ORIGIN;









  if (!no_worked)
     {
     if (IsTesting()) Print("Началось тестирование..."); else Print("Робот запущен (экспортёр сигналов v.4.00 SN)");  
     if (MWORK!=1) Print("Началась запись тиков");
     First_Time=true;
     }
     else Print("Началась запись тиков");





  LOGGING=TimeLocal()+10;
  askprev=MarketInfo(s2, MODE_ASK);
  bidprev=MarketInfo(s2, MODE_BID);
  MOI=1;
  LIVES_UP=MAX_POINT;
  LIVES_DN=MAX_POINT;
  if (CHECK_SECOND==0) z=-1; else z=0;
  PL_UP=z;
  PL_DN=z;
  TPS_Agree=true;
  TPS_Agree2=true;
  ArrayInitialize(PIP, -1);
  ArrayInitialize(FREE,true);
  if (!IsTesting() && IsConnected()) Digits_now=Digits; else Digits_now=ND;
  if (Digits_now<1) Digits_now=Digits;
  if (ORIGIN && ND!=Digits_now && !IsTesting()) Print ("кол-во знаков после точки не совпадает с чистовиком =",ND);
  hand_point=Point;
  if (hand_point==0) hand_point=MarketInfo(s2, MODE_POINT);
  if (hand_point==0) hand_point=1/MathPow(10,Digits_now);





  if (!no_worked)
  {
  j=30; z=-1; while (z==-1 && j>0) {z=FileOpen(s3+s5+".tmp", FILE_BIN|FILE_READ); j--;}
  if (z!=-1)
     {
     j=FileReadArray (z, PREV, 1, 5);
     FileClose(z);
     if (j>3)
        {
        ttl=MathAbs(TimeLocal()-PREV[5]);
        if (ttl<SMART_PROFIT_SELECT*0.5)
           {
           WAITING=PREV[3];
           DAY_MIN=PREV[1];
           DAY_MAX=PREV[2];
           First_Time2=false;}}}}}
        else Print("Началась запись тиков...");
  





  if (MWORK!=1)
     {
     q1=-1; z=250; while (q1==-1 && z>0) {q1=FileOpen(s3+".ASK",FILE_BIN|FILE_READ|FILE_WRITE); z--;}
     q2=-1; z=250; while (q2==-1 && z>0) {q2=FileOpen(s3+".BID",FILE_BIN|FILE_READ|FILE_WRITE); z--;}
     q3=-1; z=250; while (q3==-1 && z>0) {q3=FileOpen(s3+".DAT",FILE_BIN|FILE_READ|FILE_WRITE); z--;}
     if (q1*q2*q3<0)
        {
        Print ("Не получилось открыть файлы для записи тиков");
        if (MWORK==0) {Agree=false; Print ("ОСТАНОВИТЕ РАБОТУ СОВЕТНИКА!");}}}
  already_reported=false;
  TAK=TimeLocal();
  TICKER=0;
  return;
  }
//===========================================================================================================
void deinit()
  {
  string sy;
  //-------------------------------------------------------------
  if (TRANCEFER==1) DeleteFileW(DATA_PATH+s3+s5+".txt");
  if (TRANCEFER==1) DeleteFileW(DATA_PATH+"alo.txt");
  //-------------------------------------------------------------
  if (ORIGIN && TRANCEFER==0)
     {
     sy=s5+"z_"+s3+"_txt";
     if (GlobalVariableCheck(sy)) GlobalVariableDel(sy);
     sy=s5+"z_"+s3+"_ans";
     if (GlobalVariableCheck(sy)) GlobalVariableDel(sy);
     sy=s5+"z_"+s3+"_crc";
     if (GlobalVariableCheck(sy)) GlobalVariableDel(sy);
     }
  //-------------------------------------------------------------
  if (MWORK!=1)
     {
     FileClose(q1);
     FileClose(q2);
     FileClose(q3);
     }
  return;
  }



void start()
  {
  double LG, LG0, ask0, bid0, order_SL, W, W_P;
  int Lag_value, answer, DI, t, ii, WWW, U, L, ot, lp, CMD, CMD2, col, t_z, xe, Export_file, valb;
  bool what, MG_NOW_CREATE, PIP_complete;
  datetime THE_DATETIME, RDL;
  bool dir_a, dir_b, need_close;
  
  
  
  
  
  ask0=MarketInfo(s2, MODE_ASK); LG=ask0-askprev;
  bid0=MarketInfo(s2, MODE_BID); LG0=bid0-bidprev;
  THE_DATETIME=TimeLocal();



  if (THE_DATETIME>LOGGING && !First_Time2)
     {
     lp=FileOpen(s3+s5+".tmp", FILE_BIN|FILE_WRITE);
     if (lp!=-1)
        {
        PREV[1]=DAY_MIN;
        PREV[2]=DAY_MAX;
        PREV[3]=WAITING;
        PREV[5]=THE_DATETIME;
        t=FileWriteArray(lp, PREV, 1, 5);
        FileClose(lp);
     }
     else if (!already_reported)
             {
             Print ("не получилось записать промежуточные параметры режима <Суточные уровни> в файл <"+s3+s5+".tmp>");
             already_reported=true;
             }
     LOGGING=THE_DATETIME+10;
     }
  
  
  RDL=THE_DATETIME-TAK;
  TICKER++;
  if (MIN_TPS>0 && TICKER>=MIN_TPS && RDL<2) TPS_Agree2=true; else TPS_Agree2=false;
  if (MAX_TPS>0 && TICKER<=MAX_TPS && RDL>0) TPS_Agree=true; else TPS_Agree=false;
  if (RDL>0) {TICKER=0; TAK=THE_DATETIME;}


if (LG!=0 || (LG0!=0 && SPREAD_CONST==0))
   {
   if (First_Time2 && ask0>0) {DAY_MIN=ask0; DAY_MAX=ask0; WAITING=THE_DATETIME+SMART_PROFIT_SELECT; First_Time2=false;}
   Lag_value=Point_DBL_to_INT(NormalizeDouble(LG, Digits_now));
   if (SPREAD_CONST==0)
      {
      valb=Point_DBL_to_INT(NormalizeDouble(LG0,Digits_now));
      if (Lag_value<0) dir_a=true; else dir_a=false;
      if (valb<0) dir_b=true; else dir_b=false;
      if (Lag_value*valb==0 || Lag_value==valb)
         {
         if (Lag_value==0) Lag_value=valb;
         }
         else
            {
            ot=MathAbs(Lag_value);
            xe=MathAbs(valb);
            if (dir_a==dir_b) Lag_value=MathMax(ot,xe); else
               {
               if (ot!=xe)
                  {
                  if (ot>xe) Lag_value=ot-xe; else {Lag_value=xe-ot; dir_a=dir_b;}
                  }
                  else Lag_value=0;
               }
            if (dir_a) Lag_value*=-1;}}





if (!no_worked && MWORK!=0 && Lag_value!=0 && ((IsExpertEnabled() && IsConnected())))
   {




  PIP[TICKS_ALL]=Lag_value;
  PIP2[TRADE_SHIFT_ON_STOP]=Lag_value;
  PIP_complete=true; U=0;
  
  
  
  for (t=1; t<=TRADE_SHIFT_ON_STOP; t++)
      {
      ot=PIP2[t];
      if (ot==-1)
         {PIP_complete=false; if (t!=TRADE_SHIFT_ON_STOP) break;} else U+=ot;}
  
  
  
  
  
 
  
  
     if (THE_DATETIME>WAITING)
        {
        what=false;
        if (ask0>DAY_MAX)
           {
           CMD=1;
           CMD2=4;
           what=true;
           DAY_MAX=ask0;
           }
           else if (ask0<DAY_MIN)
                   {
                   CMD=0;
                   CMD2=5;
                   what=true;
                   DAY_MIN=ask0;}

        if (what)
           {
           if (MG_ZOOM>0)
              {
              xe=MOI; L=1;
              while (!FREE[L]) L++;
              MD[L]=CMD;
              MDL[L]=THE_DATETIME+MG_ZOOM;
              MS[L]=GetShift(CMD, TRADE_SHIFT_LIM, ask0, bid0);
              FREE[L]=false;
              WAIT[L]=false;
              if (L>=xe) MOI=L+1;}
           if (ORDERLIFE_ON_TURN_STOP>0)
              {
              xe=MOI; L=1;
              while (!FREE[L]) L++;
              MD[L]=CMD2;
              MDL[L]=THE_DATETIME+ORDERLIFE_ON_TURN_STOP;
              MS[L]=GetShift(CMD2, MAX_POINT, ask0, bid0);
              FREE[L]=false;
              WAIT[L]=false;
              if (L>=xe) MOI=L+1;}}}
     
     if (PIP_complete)
        {
        lp=FOUND;
        if (lp==0)
           {
           ot=MathAbs(U);
           if (ot<=TRADE_CONTROL && ot>1)
              {
              if (U>0) xe=1; else xe=-1;
              t_z=ot/2;
              W=t_z*hand_point*xe;
              PLANCA=ask0+W;
              FOUND=xe;}}
           else if (MathAbs(lp)==1)
                   {
                   LG=ask0-PLANCA;
                   col=Point_DBL_to_INT(LG);
                   if (col>0)
                      {
                      FOUND*=2;
                      LEVEL=IMPULSE_WAIT;}}
                   else
                      {
                      if (LEVEL<1)
                         {
                         ot=MathAbs(U);
                         if (ot<=TRADE_CONTROL && ot>1)
                            {
                            DI=FOUND/2;
                            if (DI>0) MG_NOW_CREATE=true; else MG_NOW_CREATE=false;
                            CMD=4+MG_NOW_CREATE;
                            CMD2=!MG_NOW_CREATE;
                            if (MATCH_LIMIT_ORDERS>0)
                               {
                               xe=MOI; L=1;
                               while (!FREE[L]) L++;
                               MD[L]=CMD;
                               MDL[L]=THE_DATETIME+MATCH_LIMIT_ORDERS;
                               MS[L]=GetShift(CMD, LOSS_INSPECTION, ask0, bid0);
                               FREE[L]=false;
                               WAIT[L]=false;
                               if (L>=xe) MOI=L+1;
                               }
                            if (TRADE_SHIFT_REV>0)
                               {
                               xe=MOI; L=1;
                               while (!FREE[L]) L++;
                               MD[L]=CMD2;
                               MDL[L]=THE_DATETIME+TRADE_SHIFT_REV;
                               MS[L]=GetShift(CMD2, ORDERLIFE_REV, ask0, bid0);
                               FREE[L]=false;
                               WAIT[L]=false;
                               if (L>=xe) MOI=L+1;}}
                         FOUND=0;}
                         else LEVEL--;}}

     what=true;
     for (t=1; t<=TICKS_ALL; t++) if (PIP[t]==-1) {what=false; if (t!=TICKS_ALL) break;}
     if (what)
        {
     U=0;
     ot=0;
     CMD=0;
     lp=NormalizeDouble(TICKS_ALL*PERCENT_OF_CUT/100,0);
     for (t=TICKS_ALL; t>lp; t--) {U+=PIP[t]; ot+=PIP[t-lp];}
     if (U>0) PIP_complete=true; else PIP_complete=false;
     if (ot>0) MG_NOW_CREATE=true; else MG_NOW_CREATE=false;
     lp=MathAbs(U);
     ii=MathAbs(ot);
     //---------------------------------------------------------------------
     if (lp>RISE_VECTOR && lp<RISE_VECTOR+CRUSER_MODE && ii>RISE_PIPS2 && ii<RISE_PIPS2+CHANNEL_OLD2 && PIP_complete!=MG_NOW_CREATE)
        {
           if (AG_DEPTH)
              {
              CMD=MG_NOW_CREATE;
              CMD2=5-PIP_complete;
              }
              else
                 {
                 CMD=4+PIP_complete;
                 CMD2=!PIP_complete;
                 }
           if (ORDERLIFE>0)
              {
              xe=MOI; L=1;
              while (!FREE[L]) L++;
              MD[L]=CMD;
              MDL[L]=THE_DATETIME+ORDERLIFE;
              MS[L]=GetShift(CMD, TRADE_SHIFT, ask0, bid0);
              FREE[L]=false;
              WAIT[L]=false;
              if (L>=xe) MOI=L+1;
              }
           if (CHECK_SECOND>0)
              {
              xe=MOI; L=1;
              while (!FREE[L]) L++;
              MD[L]=CMD2;
              MDL[L]=THE_DATETIME+CHECK_SECOND;
              MS[L]=GetShift(CMD2, ORDERLIFE_LIM, ask0, bid0);
              FREE[L]=false;
              WAIT[L]=false;
              if (L>=xe) MOI=L+1;
              }}}
 

  DI=1;


  if (MOI>1)
     {
     for (t=1; t<MOI; t++) if (!FREE[t])
         {
         if (MDL[t]>THE_DATETIME)
            {
            if ((MIN_TPS==0 || TPS_Agree2) && (MAX_TPS==0 || TPS_Agree))
               {
               order_SL=MS[t];
               WWW=MD[t];
               lp=WWW;
               if (WWW>1) WWW-=4;
               if (lp<2) {if (lp==0) W_P=ask0; else W=bid0;} else if (lp==4) W_P=bid0; else W=ask0;
               if ((W>=order_SL && WWW==1) || (W_P<=order_SL && WWW==0))
                  {
                  if (DELETE_PENDINGS_ORDERS && WAIT[t]) WWW=!PIP_complete; else if (lp>1) WWW=1-WWW;
                  Direction[DI]=WWW;
                  MMM0[DI]=t;
                  DI++;}}
                  else if (DELETE_PENDINGS_ORDERS) WAIT[t]=true;}
               else FREE[t]=true;}}










  if (Agree && DI>1)
     {
     for (t=1; t<DI; t++)
         {
         WWW=Direction[t];
         if (WWW!=-1)
            {
            answer=-1;
            what=false;
            if (TRANCEFER==1)
            {
            if (!First_Time) answer=CreateFileW(DATA_PATH+s3+s5+".ans", FILE_BIN|FILE_READ|FILE_WRITE, 1, 0, 4, 32, 2);
            if (answer>-1 || First_Time)
               {
               if (!First_Time)
                  {
                  ot=0;
                  need_close=true;
                  if (GetFileSize(answer, bytesread)>0)
                     {
                     ReadFile(answer, lo, 1, bytesread, 0);
                     ot=lo[0];
                     }
                  if (ot==Treasure) what=true;
                  }
                  else what=true;
               }
            if (what)
               {
               if (First_Time) First_Time=false;
               if (MMM0[t]!=0) FREE[MMM0[t]]=true;
               if (answer>-1)
                  {
                  _llseek(answer, 0, 0);
                  lo[0]=0;
                  WriteFile(answer, lo, 1, IOS, 0);
                  CloseHandle(answer);
                  need_close=false;
                  }
               Export_file=CreateFileW(DATA_PATH+s3+s5+".txt", FILE_BIN|FILE_READ|FILE_WRITE, 1, 0, 4, 32, 2);
               if (Export_file>-1)
                  {
                  Direction[t]=-1;
                  lo[0]=WWW+1;
                  WriteFile(Export_file, lo, 1, IOS, 0);
                  lo[0]=Treasure;
                  WriteFile(Export_file, lo, 1, IOS, 0);
                  CloseHandle(Export_file);}}
            if (answer!=-1 && need_close) CloseHandle(answer);
            }
            else
            {
            if (!GlobalVariableCheck(s5+"z_"+s3+"_ans")) GlobalVariableSet(s5+"z_"+s3+"_ans",-1); else if (!First_Time) answer=GlobalVariableGet(s5+"z_"+s3+"_ans");
            if (First_Time || answer==Treasure) what=true;
            if (what)
               {
               if (First_Time) First_Time=false;
               if (MMM0[t]>0) FREE[MMM0[t]]=true;
               if (answer>-1) GlobalVariableSet(s5+"z_"+s3+"_ans",0);
               Direction[t]=-1;
               GlobalVariableSet(s5+"z_"+s3+"_txt",WWW+1);
               GlobalVariableSet(s5+"z_"+s3+"_crc",Treasure);
               }}
            if (GlobalVariableGet("TRADE_START_GLOBAL")==0)
               {
               GlobalVariableSet("TRADE_START_GLOBAL", 1);
               PlaySound("ringin.wav");}}}}





   askprev=ask0;
   if (SPREAD_CONST==0) bidprev=bid0;
   L=MathMax(TICKS_ALL, TRADE_SHIFT_ON_STOP);



   for (ii=2; ii<=L; ii++)
       {
       if (ii<=TICKS_ALL) PIP[ii-1]=PIP[ii];
       if (ii<=TRADE_SHIFT_ON_STOP) PIP2[ii-1]=PIP2[ii];
       }}}




  if (MWORK!=1)
     {
     FileSeek(q1, 0, SEEK_END);
     FileWriteDouble (q1, ask0, DOUBLE_VALUE);
     FileSeek(q2, 0, SEEK_END);
     FileWriteDouble (q2, bid0, DOUBLE_VALUE);
     FileSeek(q3, 0, SEEK_END);
     if (USE_LOCAL_TIME==1) THE_DATETIME=TimeLocal(); else THE_DATETIME=TimeCurrent();
     FileWriteInteger(q3, THE_DATETIME, LONG_VALUE);
     }
  return;
  }



int Point_DBL_to_INT(double chk)
    {
    string st, sq;
    int sf, sl, sqt;
    st=DoubleToStr(chk, Digits_now);
    sf=StringFind(st, ".", 0)+1;
    sq=StringSubstr(st, 0, sf-1);
    sqt=StrToInteger(sq);
    if (sf==0) return (chk);
    sl=StringLen(st)-1;
    st=StringSubstr(st, sf, sl);
    if (sqt!=0) sf=StrToInteger(sq+st); else
       {
       sf=StrToInteger(st);
       if (chk<0) sf=-sf;
       }
    return (sf);
    }
double GetShift(int CMD0, int W1, double ask1, double bid1)
       {
       double bsd;
       if (CMD0==0 || CMD0==4) bsd=ask1-W1*hand_point; else bsd=bid1+W1*hand_point;
       return (bsd);
       }
void StartRetreive()
     {
     DAT[22]=MathAbs(DAT[22]);
     DAT[48]=MathAbs(DAT[48]);
     //-----------------------------------------------------------------------
     SMART_PROFIT_SELECT=DAT[54];
     TRADE_CONTROL=DAT[13];
     IMPULSE_WAIT=DAT[58];
     ORDERLIFE_REV=DAT[24];
     CRUSER_MODE=DAT[6];
     MAX_POINT=DAT[38];
     MATCH_LIMIT_ORDERS=DAT[2];
     LOSS_INSPECTION=DAT[3];
     TRADE_SHIFT_LIM=DAT[34];
     RISE_PIPS2=DAT[32];
     TICKS_ALL=DAT[30];
     ORDERLIFE_LIM=DAT[29];
     ORDERLIFE=DAT[26];
     RISE_VECTOR=DAT[23];
     ND=DAT[21];
     MAX_TPS=DAT[20];
     MG_ZOOM=DAT[25];
     DELETE_PENDINGS_ORDERS=DAT[42];
     TRADE_SHIFT=DAT[18];
     PERCENT_OF_CUT=DAT[33-RID[0]];
     CHECK_SECOND=DAT[39];
     TRADE_SHIFT_ON_STOP=DAT[44];
     ORDERLIFE_ON_TURN_STOP=DAT[45];
     MIN_TPS=DAT[50];
     CHANNEL_OLD2=DAT[52];
     AG_DEPTH=DAT[53];
     TRADE_SHIFT_REV=DAT[56];
     Print ("Прибыль чистовика="+DoubleToStr(DAT[49-RID[0]],2));
     return;
     }