sydiv_v0.1.mq4

#define NO_ERROR              1
#define AT_LEAST_ONE_FAILED   2

extern string  ZZ_Info="Zig Zag Parameters";
input int      ExtDepth=12;
input int      ExtDeviation=5;
input int      ExtBackstep=2;
input int      Zig_Zag_Back=150; // Zig Zag Bars Back
extern string  Order_Info="Orders Parameters";
input double   BreakTrail_Point=5.0; //BE & Trail Points
input int      Max_Orders=3; // Maximum Orders
input int      Amplitude=30;
input double   Aux_Buy_Weight=0.75; // Aux Buy Weight 
input double   Aux_Sell_Weight=0.75; // Aux Sell Weight
input bool     Money_Management=True; // Auto Management ?
input double   Margin_Percent=0.3; // Margin Percent
input double   Lot_Size=0.01; // Manual Lot Size
input bool     Neutralizer=True;
input int      Retry=5;
input int      Slippage=5;
input int      MN_Buy_Original=1234;
input int      MN_Sell_Original=1235;
input int      MN_Aux=1236;

int MaxPos=Max_Orders;

datetime order_time = 0;

int init()
  {
      // код доступен только после оплаты
   }

int deinit()
  {

   return(0);
  }

int start()
{
      // код доступен только после оплаты
   }

TrailingAlls(BreakTrail_Point, 10);

int i=0, Initialize=0, ZZ_Increment_GO=0;
double Zig_Zag_Value=0, ZZ_RSI_T0=0, ZZ_RSI_T1=0;
static int Loaded=0;
int Buy_Signal=0, Sell_Signal=0;
static double ZZ_Collect[][2], ZZ_Ref=0, Target=0, Invalidation=0;
static datetime Time_Recorded=0;

ArrayResize(ZZ_Collect, Zig_Zag_Back);
ArrayFill(ZZ_Collect,0,Zig_Zag_Back,NULL);
ArraySetAsSeries(ZZ_Collect, True);

int Pos_Open=0, h=0;
int Sell_Position=0, Buy_Position=0, Aux_Position=0, Sell_Loser=0, Buy_Loser=0, Sell_Winner=0, Buy_Winner=0, Aux_Direction=0;
int a=-1, b=-1, c=0;
static int Repopulate=0;
static int Counting=0;
static int Neutralize=0;
double Profit_Buy=0, Profit_Sell=0, Profit_Temp=0, Profit_Aux=0;
double Buy_Loss=0, Sell_Loss=0, Buy_Profit=0, Sell_Profit=0, Aux_Profit=0;
double Buy_Loss_Array[][2], Buy_Profit_Array[][2], Sell_Loss_Array[][2], Sell_Profit_Array[][2], Aux_Array[][2], Aux_Array_Target[][2];

if(ArraySize(Buy_Loss_Array)!=MaxPos*4)
  ArrayResize(Buy_Loss_Array,MaxPos*4);
if(ArraySize(Buy_Profit_Array)!=MaxPos*4)
  ArrayResize(Buy_Profit_Array,MaxPos*4);
if(ArraySize(Sell_Loss_Array)!=MaxPos*4)
  ArrayResize(Sell_Loss_Array,MaxPos*4);
if(ArraySize(Sell_Profit_Array)!=MaxPos*4)
  ArrayResize(Sell_Profit_Array,MaxPos*4);
if(ArraySize(Aux_Array)!=MaxPos*4)
  ArrayResize(Aux_Array,MaxPos*4);
if(ArraySize(Aux_Array_Target)!=MaxPos*4)
  ArrayResize(Aux_Array_Target,MaxPos*4);

for(h=OrdersTotal()-1;h>=0;h--)
  {
    if(OrderSelect(h,SELECT_BY_POS,MODE_TRADES)==true)
      {
        if(OrderMagicNumber()==MN_Sell_Original || OrderMagicNumber()==MN_Buy_Original || OrderMagicNumber()==MN_Aux)
         {      

           if(OrderMagicNumber()==MN_Sell_Original)
           {  
           Pos_Open++;
           Sell_Position++;
           Profit_Temp = OrderProfit()+OrderCommission()+OrderSwap();
           if(Profit_Temp<0)
             {
             Sell_Loser++;
             Sell_Loss += Profit_Temp;
             }
           if(Profit_Temp>=0)
             {
             Sell_Winner++;
             Sell_Profit += Profit_Temp;
             }
           Profit_Sell += Profit_Temp;
           } 

           if(OrderMagicNumber()==MN_Buy_Original)
           { 
           Pos_Open++;
           Buy_Position++;
           Profit_Temp = OrderProfit()+OrderCommission()+OrderSwap();
           if(Profit_Temp<0)
             {
             Buy_Loser++;
             Buy_Loss += Profit_Temp;
             }
           if(Profit_Temp>=0)
             {
             Buy_Winner++;
             Buy_Profit += Profit_Temp;
             }
           Profit_Buy += Profit_Temp;
           }

           if(OrderMagicNumber()==MN_Aux)
           {
           Pos_Open++;
           Aux_Position++;
           Profit_Temp = OrderProfit()+OrderCommission()+OrderSwap();
           Profit_Aux += Profit_Temp;
           if(ORDER_TYPE==OP_BUY)
             Aux_Direction=1;
           if(ORDER_TYPE==OP_SELL)
             Aux_Direction=-1;
           }           

         }
      }
  }

if(Loaded==1 && Pos_Open==0)
  {
  Loaded=0;
  Buy_Signal=0;
  Sell_Signal=0;
  }

if(Time_Recorded+Zig_Zag_Back*30<Time[0])
{
for(i=1; i<=Zig_Zag_Back; i++)
  {
  Zig_Zag_Value=ZigZag(i);
  if(Zig_Zag_Value==0)
    continue;

  if(Zig_Zag_Value!=0 && ZZ_Increment_GO==0)
    {
    ZZ_Collect[0][0]=Zig_Zag_Value;
    ZZ_Collect[0][1]=i;
    ZZ_Increment_GO=1;
    continue;
    }
  if(Zig_Zag_Value!=0 && ZZ_Increment_GO!=0)
    {
    ZZ_Collect[ZZ_Increment_GO][0]=Zig_Zag_Value;
    ZZ_Collect[ZZ_Increment_GO][1]=i;
    ZZ_Increment_GO++;
    continue;
    }
  }

for(i=1; i<=ZZ_Increment_GO; i++)
{
if(ZZ_Collect[i][0]>ZZ_Collect[i+1][0] && ZZ_Collect[i+1][0]<ZZ_Collect[i+2][0] && ZZ_Collect[i][0]>ZZ_Collect[i+2][0])
  {

  ZZ_RSI_T0=iRSI(Symbol() , Period(), 14, PRICE_CLOSE, ZZ_Collect[i][1]);
  ZZ_RSI_T1=iRSI(Symbol() , Period(), 14, PRICE_CLOSE, ZZ_Collect[i+2][1]);
  if(ZZ_RSI_T1>ZZ_RSI_T0 && ZZ_RSI_T1>70)
    {
    Target=ZZ_Collect[i+1][0];
    Invalidation=ZZ_Collect[i][0];
    Sell_Signal++;
    }
  else
    continue;
  }

if(ZZ_Collect[i][0]<ZZ_Collect[i+1][0] && ZZ_Collect[i+1][0]>ZZ_Collect[i+2][0] && ZZ_Collect[i][0]<ZZ_Collect[i+2][0])
  {

  ZZ_RSI_T0=iRSI(Symbol() , Period(), 14, PRICE_CLOSE, ZZ_Collect[i][1]);
  ZZ_RSI_T1=iRSI(Symbol() , Period(), 14, PRICE_CLOSE, ZZ_Collect[i+2][1]);
  if(ZZ_RSI_T1<ZZ_RSI_T0 && ZZ_RSI_T1<30)
    {
    Target=ZZ_Collect[i+1][0];
    Invalidation=ZZ_Collect[i][0];
    Buy_Signal++;
    }
  }
}

Time_Recorded=Time[0];

}

static double Lot_Size_Adjusted=0;
int LotsDigit=0;
double MinLots=0, MaxLots=0, AcFrMar=0, Step=0, One_Lot=0;

if(Money_Management==0)
   Lot_Size_Adjusted=Lot_Size;

if(Money_Management==1 && Pos_Open==0)
   {
   if(MarketInfo(Symbol(),MODE_MINLOT) == 0.1)
     LotsDigit=1;
   else if(MarketInfo(Symbol(),MODE_MINLOT) == 0.01)
     LotsDigit=2;

   One_Lot=MarketInfo(Symbol(),MODE_MARGINREQUIRED);

   Step=MarketInfo(Symbol(),MODE_LOTSTEP);

   MinLots=NormalizeDouble(MarketInfo(Symbol(),MODE_MINLOT),LotsDigit);
   MaxLots=NormalizeDouble(MarketInfo(Symbol(),MODE_MAXLOT),LotsDigit);

   AcFrMar=NormalizeDouble(AccountFreeMargin(),2);

   Lot_Size_Adjusted=MathFloor(AcFrMar*Margin_Percent/100/One_Lot/Step)*Step;

   if(Lot_Size_Adjusted>MaxLots)
     Lot_Size_Adjusted=MaxLots;
   if(Lot_Size_Adjusted<MinLots)
     Lot_Size_Adjusted=MinLots; 
   }

int Order_Number=0, Order_Number_2=0;

if(Buy_Signal>Sell_Signal && CheckStopLoss_Takeprofit(OP_BUY, 0, 0) && Pos_Open<Max_Orders)
  {
  for(i=0; i<Retry; i++)
      {
      Order_Number=-1;
      RefreshRates();
      Order_Number=OrderSend(_Symbol,OP_BUY,Lot_Size_Adjusted,MarketInfo(_Symbol,MODE_ASK),Slippage ,0 ,0, NULL,MN_Buy_Original,0,Blue);
      if(Order_Number_2>=0)
        break;
      }
  Print("BUY = ", Buy_Signal, "/ SELL = ", Sell_Signal);
  Buy_Signal=0;
  Sell_Signal=0;
  Loaded=1;

  }

if(Sell_Signal>Buy_Signal && CheckStopLoss_Takeprofit(OP_SELL, 0, 0) && Pos_Open<Max_Orders)
  {
  for(i=0; i<Retry; i++)
      {
      Order_Number=-1;
      RefreshRates();
      Order_Number=OrderSend(_Symbol,OP_SELL,Lot_Size_Adjusted,MarketInfo(_Symbol,MODE_BID),Slippage ,0 , 0,NULL,MN_Sell_Original,0,Red);
      if(Order_Number_2>=0)
        break;
      }
  Print("BUY = ", Buy_Signal, "/ SELL = ", Sell_Signal);
  Buy_Signal=0;
  Sell_Signal=0;
  Loaded=1;

  }

if(Counting!=Aux_Position)
  {

  a=-1;
  b=-1;
  Counting=Aux_Position;
  }

if(Neutralize==0 && Aux_Position!=0)
  {
  Neutralize=1;
  Print("Neutralization starting...");
  }

if(Neutralize>0 && Aux_Position==0)
  {
  Neutralize=0;
  Buy_Signal=0;
  Sell_Signal=0;
  Repopulate=1;
  Print("Neutralization over !");
  }

double Profit=0;
double Buy_Loss_Cached=0, Sell_Loss_Cached=0, Buy_Profit_Cached=0, Sell_Profit_Cached=0;
int Worst_Buy_Position=0, Worst_Sell_Position=0, Best_Buy_Position=0, Best_Sell_Position=0;
double Worst_Buy_Price=0, Worst_Sell_Price=0, Best_Buy_Price=0, Best_Sell_Price=0;
int pos=0, v=-1, w=-1, x=-1, y=-1, z=-1;
int index=0, Aux_Position_Ticket=0;

ResetOrderArray(Buy_Loss_Array, Buy_Profit_Array, Sell_Loss_Array, Sell_Profit_Array, Aux_Array);

static datetime Time_Cached;
static int WSP_Cached=0, WBP_Cached=0;
static int d=0, e=0;
double ATR_Bis=0;

if(iATR(_Symbol, Period(),100,10)!=0)
  ATR_Bis=(MathPow((iATR(_Symbol,Period(),10,0)/iATR(_Symbol,Period(),100,10)/10/_Point), Amplitude));

if(Repopulate==1)
  {
  ResetOrderArrayTarget(Aux_Array_Target);
  while(Aux_Array_Target[c][0]!=0 || Aux_Array_Target[c][1]!=0)
    {
    c++;
    }

  d=0;
  e=0;
  Repopulate=0;
  }

Profit = Profit_Buy + Profit_Sell + Profit_Aux;

if(Profit<0 && Neutralizer==True)
{
for(pos=OrdersTotal()-1; pos>=0; pos--)
  {
  if(OrderSelect(pos, SELECT_BY_POS, MODE_TRADES)==True)
    {

    if(OrderMagicNumber()==MN_Buy_Original)
    {
    Profit_Temp = OrderProfit()+OrderCommission()+OrderSwap();

    if(0>Profit_Temp)
      {
      Buy_Loss_Cached=NormalizeDouble(Profit_Temp,2);
      Worst_Buy_Position=OrderTicket();
      Worst_Buy_Price=OrderOpenPrice();
      w++;
      Buy_Loss_Array[w][0]=Worst_Buy_Position;
      Buy_Loss_Array[w][1]=Buy_Loss_Cached;
      if(Sell_Signal>Buy_Signal && d<Buy_Position && ((CountBuyPips()/CountBuyOrders()<-MathLog10(ATR_Bis)*Aux_Sell_Weight)))
        {

        ArraySort(Aux_Array_Target, WHOLE_ARRAY, 0, MODE_DESCEND);
        index=ArrayBsearch(Aux_Array_Target, Worst_Buy_Position, WHOLE_ARRAY, 0, MODE_DESCEND);

        if(Aux_Array_Target[index][0]!=Worst_Buy_Position)
        {

        a=index;

        while(Aux_Array_Target[a][0]!=0 && !IsStopped())
          {
          a++;
          }

        d++;
        Counting++;

        Aux_Array_Target[a][0]=Worst_Buy_Position;
        Aux_Array_Target[a][1]=0;

        Time_Cached=OrderLaunch("SELL", 2, Aux_Array_Target, a);
        Sell_Signal=0;
        }

        }

      }

    if(0<Profit_Temp)
      {
      Buy_Profit_Cached=NormalizeDouble(Profit_Temp,2);
      Best_Buy_Position=OrderTicket();
      Best_Buy_Price=OrderOpenPrice();
      x++;
      Buy_Profit_Array[x][0]=Best_Buy_Position;
      Buy_Profit_Array[x][1]=Buy_Profit_Cached;

      }
    }

    if(OrderMagicNumber()==MN_Sell_Original)
    {
    Profit_Temp = OrderProfit()+OrderCommission()+OrderSwap();

    if(0>Profit_Temp)
      {
      Sell_Loss_Cached=NormalizeDouble(Profit_Temp,2);
      Worst_Sell_Position=OrderTicket();
      Worst_Sell_Price=OrderOpenPrice();
      y++;
      Sell_Loss_Array[y][0]=Worst_Sell_Position;
      Sell_Loss_Array[y][1]=Sell_Loss_Cached;
      if(Buy_Signal>Sell_Signal && e<Sell_Position && ((CountSellPips()/CountSellOrders()<-MathLog10(ATR_Bis)*Aux_Buy_Weight)))
        {

        ArraySort(Aux_Array_Target, WHOLE_ARRAY, 0, MODE_DESCEND);
        index=ArrayBsearch(Aux_Array_Target, Worst_Sell_Position, WHOLE_ARRAY, 0, MODE_DESCEND);

        if(Aux_Array_Target[index][0]!=Worst_Sell_Position)
        {

        b=index;

        while(Aux_Array_Target[b][0]!=0 && !IsStopped())
          {
          b++;
          }

        e++;
        Counting++;

        Aux_Array_Target[b][0]=Worst_Sell_Position;
        Aux_Array_Target[b][1]=0;

        Time_Cached=OrderLaunch("BUY", 2, Aux_Array_Target, b);
        Buy_Signal=0;
        }

        }

      }

    if(0<Profit_Temp)
      {
      Sell_Profit_Cached=NormalizeDouble(Profit_Temp,2);
      Best_Sell_Position=OrderTicket();
      Best_Sell_Price=OrderOpenPrice();
      z++;
      Sell_Profit_Array[z][0]=Best_Sell_Position;
      Sell_Profit_Array[z][1]=Sell_Profit_Cached;

      }
    }

    if(OrderMagicNumber()==MN_Aux)
      {
      Profit_Temp = OrderProfit()+OrderCommission()+OrderSwap();
      Aux_Profit=NormalizeDouble(Profit_Temp,2);
      Aux_Position_Ticket=OrderTicket();
      v++;
      Aux_Array[v][0]=Aux_Position_Ticket;
      Aux_Array[v][1]=Aux_Profit;
      Aux_Profit += Profit_Temp;
      }

    }
  }
}

int u=0;
string Order_Ticket_Proxy;
double Temp_Loss=0, Temp_Win=0, Temp_Equal=0, Temp_Aux=0;
double Loss_Cached=0, Aux_Cached=0, Loss_Sell_Cached=10000, Loss_Buy_Cached=10000;
string Loss_Buy_Ticket_Cached, Loss_Sell_Ticket_Cached, Loss_Ticket_Cached, Win_Ticket_Cached, Aux_Ticket_Cached;

if(Neutralize==1)// && Lyapunov(1)>0)
  {

  Loss_Buy_Cached=0;
  Loss_Sell_Cached=0;
  Aux_Cached=0;

  ArraySort(Buy_Loss_Array, WHOLE_ARRAY, 0, MODE_ASCEND);
  ArraySort(Sell_Loss_Array, WHOLE_ARRAY, 0, MODE_ASCEND);
  ArraySort(Aux_Array, WHOLE_ARRAY, 0, MODE_DESCEND);  

  for(u=0; u<MaxPos*4; u++)
    {
    Temp_Loss=Buy_Loss_Array[u][1];
    if(Temp_Loss<Loss_Buy_Cached)
      {
      Loss_Buy_Cached=Temp_Loss;
      Loss_Buy_Ticket_Cached=DoubleToStr(Buy_Loss_Array[u][0],0);
      }

    Temp_Loss=Sell_Loss_Array[u][1];
    if(Temp_Loss<Loss_Sell_Cached)
      {
      Loss_Sell_Cached=Temp_Loss;
      Loss_Sell_Ticket_Cached=DoubleToStr(Sell_Loss_Array[u][0],0);
      }

    Temp_Aux=Aux_Array[u][1];
    if(Temp_Aux>Aux_Cached)
      {
      Aux_Cached=Temp_Aux;
      Aux_Ticket_Cached=DoubleToStr(Aux_Array[u][0],0);
      }
    }

  if(OrderSelect(StrToInteger(Aux_Ticket_Cached), SELECT_BY_TICKET, MODE_TRADES)==True)
      if(OrderMagicNumber()==MN_Aux)
      {
      Aux_Profit=OrderProfit()+OrderCommission()+OrderSwap();
      Order_Ticket_Proxy=IntegerToString(OrderTicket());
      if(OrderType()==OP_BUY && Aux_Profit+Loss_Sell_Cached>=0)
        {

        CloseSelected(Loss_Sell_Ticket_Cached, Retry);
        CloseSelected(Order_Ticket_Proxy, Retry);
        return(0);
        }
      if(OrderType()==OP_SELL && Aux_Profit+Loss_Buy_Cached>=0)
        {

        CloseSelected(Loss_Buy_Ticket_Cached, Retry);
        CloseSelected(Order_Ticket_Proxy, Retry);
        return(0);
        }
      }
  }

if(Neutralize==0 && Sell_Profit!=0 && Buy_Loss!=0 && Sell_Profit>MathAbs(Buy_Loss))// && x>w)
  {

  ArraySort(Buy_Loss_Array, WHOLE_ARRAY, 0, MODE_ASCEND);
  ArraySort(Sell_Profit_Array, WHOLE_ARRAY, 0, MODE_DESCEND);

  for(u=0; u<MaxPos*4; u++)
    {

      if(Buy_Loss_Array[u][0]==0)
        continue;
      Temp_Loss=Buy_Loss_Array[u][1];
      if(Temp_Loss<Loss_Cached)
        {
        Loss_Cached=Temp_Loss;
        Loss_Ticket_Cached=DoubleToStr(Buy_Loss_Array[u][0],0);
        continue;
        }

    }

  if(CloseSelected(Loss_Ticket_Cached, Retry)==True)
    Temp_Equal=Loss_Cached;

  for(u=0; u<MaxPos*4; u++)
    {
      if(Sell_Profit_Array[u][0]==0)
        continue;
      Temp_Win=Sell_Profit_Array[u][1];
      Win_Ticket_Cached=DoubleToStr(Sell_Profit_Array[u][0],0);
      if(Temp_Equal<0)
        {

        if(CloseSelected(Win_Ticket_Cached, Retry)==True)
          Temp_Equal += Temp_Win;
        else
          Print("Error");
        }
      if(Temp_Equal>=0)
        break;

    }
  Temp_Equal=0;
  }

if(Neutralize==0 && Sell_Loss!=0 && Buy_Profit!=0 && MathAbs(Sell_Loss)<Buy_Profit)// && z>y)
  {

  ArraySort(Sell_Loss_Array, WHOLE_ARRAY, 0, MODE_ASCEND);
  ArraySort(Buy_Profit_Array, WHOLE_ARRAY, 0, MODE_DESCEND);

  for(u=0; u<MaxPos*4; u++)
    {

      if(Sell_Loss_Array[u][0]==0)
        continue;
      Temp_Loss=Sell_Loss_Array[u][1];
      if(Temp_Loss<Loss_Cached)
        {
        Loss_Cached=Temp_Loss;
        Loss_Ticket_Cached=DoubleToStr(Sell_Loss_Array[u][0],0);
        continue;
        }

    }

  if(CloseSelected(Loss_Ticket_Cached, Retry)==True)
    Temp_Equal=Loss_Cached;

  for(u=0; u<MaxPos*4; u++)
    {
      if(Buy_Profit_Array[u][0]==0)
        continue;
      Temp_Win=Buy_Profit_Array[u][1];
      Win_Ticket_Cached=DoubleToStr(Buy_Profit_Array[u][0],0);
      if(Temp_Equal<0)
        {

        if(CloseSelected(Win_Ticket_Cached, Retry)==True)
          Temp_Equal += Temp_Win;
        else
          Print("Error");
        }
      if(Temp_Equal>=0)
        break;

    }
  Temp_Equal=0;
  }

double Lot_Size_Empowered=0;

if(Neutralize==1 && ((Profit_Buy!=0 && Profit_Aux<Profit_Buy) || (Profit_Sell!=0 && Profit_Aux<Profit_Sell) || (Buy_Position==0 && Sell_Position==0)))
  {
  if(Profit_Buy!=0 && Profit_Aux*2<Profit_Buy/2 && Buy_Signal!=0)
    {
    Lot_Size_Empowered=(Buy_Position+Aux_Position)*4*Lot_Size;
    for(i=0; i<Retry; i++)
          {
          RefreshRates();
          Order_Number=-1;
          Order_Number=OrderSend(_Symbol,OP_BUY,Lot_Size_Empowered,MarketInfo(_Symbol,MODE_ASK),Slippage,0,0,NULL,MN_Aux,0,Gold);
          if(Order_Number>0)
            {
            if(OrderSelect(Order_Number,SELECT_BY_TICKET)==True)
              {

              }
            break;
            }
          }
    Buy_Signal=0;
    Neutralize=2;
    }
  if(Profit_Sell!=0 && Profit_Aux*2<Profit_Sell/2 && Sell_Signal!=0)
    {
    Lot_Size_Empowered=(Sell_Position+Aux_Position)*4*Lot_Size;
    for(i=0; i<Retry; i++)
          {
          RefreshRates();
          Order_Number=-1;
          Order_Number=OrderSend(_Symbol,OP_SELL,Lot_Size_Empowered,MarketInfo(_Symbol,MODE_BID),Slippage,0,0,NULL,MN_Aux,0,Gold);
          if(Order_Number>0)
            {
            if(OrderSelect(Order_Number,SELECT_BY_TICKET)==True)
              {

              }
            break;
            }
          }
    Sell_Signal=0;
    Neutralize=2;
    }
  if(Buy_Position==0 && Sell_Position==0)
   {
   if(Aux_Direction==1)// && Sell_Signal!=0)
     {
     Lot_Size_Empowered=(Aux_Position*4)*Lot_Size;
     for(i=0; i<Retry; i++)
          {
          RefreshRates();
          Order_Number=-1;
          Order_Number=OrderSend(_Symbol,OP_SELL,Lot_Size_Empowered,MarketInfo(_Symbol,MODE_BID),Slippage,0,0,NULL,MN_Aux,0,Gold);
          if(Order_Number>0)
            {
            if(OrderSelect(Order_Number,SELECT_BY_TICKET)==True)
              {

              }
   

Показано первые 50% кода (символов: 26043)