/*
   G e n e r a t e d  by ex4-to-mq4 decompiler FREEWARE 4.0.509.5
   Website:  h T Tp://w w W .meT a q U O T E S. Ne T
   E-mail : s up POR T @ M e TaqUOt Es. N ET
*/
#property copyright "NeuralTraders.info"
#property link      "NeuralTraders.info "

//#include <stdlib.mqh>
#import "stdlib.ex4"
   string ErrorDescription(int a0); // DA69CBAFF4D38B87377667EEC549DE5A
#import "Fann2MQL.dll"
   int f2M_create_standard(int a0, int a1, int a2, int a3, int a4);
   int f2M_run(int a0, double& a1[]);
   int f2M_destroy(int a0);
   double f2M_get_output(int a0, int a1);
   int f2M_train(int a0, double& a1[], double& a2[]);
   int f2M_randomize_weights(int a0, double a1, double a2);
   double f2M_get_MSE(int a0);
   int f2M_set_act_function_hidden(int a0, int a1);
   int f2M_set_act_function_output(int a0, int a1);
   int f2M_parallel_init();
   int f2M_parallel_deinit();
#import "kernel32.dll"
   int GetTimeZoneInformation(int& a0[]);
#import

int Gi_76 = 0;
string Gs_80 = "NEXTCLOSE-V156-";
extern double Lots = 0.01;
extern bool UseMoneyManagement = TRUE;
extern double RiskFactor = 0.2;
extern int MAGIC_NUM = 34779;
extern int Stop = 140;
extern int Trail = 15;
extern int TakeProfit = 10;
extern bool UseFixedTP = TRUE;
extern bool TrailFractal = FALSE;
extern bool ContinuousMode = FALSE;
extern int RiskReducer = 2;
extern int Epochs = 380;
extern int MaxEpochs = 1200;
extern double ForceIndex = 5.5;
extern bool TradeOnSunday = FALSE;
int Gi_unused_160 = -1;
int Gi_unused_164 = 0;
int Gi_unused_168 = -1;
double Gda_unused_172[];
double Gda_unused_176[];
double Gda_180[24];
int Gi_184;
int Gi_188 = WHOLE_ARRAY;
datetime G_time_192 = 0;
double Gd_196 = 0.1;
int Gi_204 = 4800;
int Gi_208 = 2;
int Gi_unused_212 = -1;
string Gs_216;
extern double MinMSE = 0.0000025;
extern bool TimeFilter = TRUE;
extern int SlidingWindow = 32;
extern int CloseAfter = 2;
extern int BeginHour = 17;
extern int EndHour = 1;
extern int Threshhold = 8;
extern int Offset = 2;
int Gi_260 = 20;
extern bool AutoAdjustDigits = TRUE;
int G_count_268 = 0;
bool Gi_272 = FALSE;
string Gs_276 = "SL set to low of 10 bars";
string Gs_284 = "";
int G_day_of_week_292 = -1;
string Gs_unused_296 = "  Trading will begin at GMT:";

int getTimeFrame() {
   return (Period());
}

double getLots(double Ad_0, bool Ai_8, double Ad_12) {
   if (!Ai_8) return (Ad_12);
   double Ld_ret_20 = Ad_0 * (AccountEquity() / 10000.0);
   double Ld_28 = MarketInfo(Symbol(), MODE_MINLOT);
   if (Ld_ret_20 < Ld_28) Ld_ret_20 = Ld_28;
   return (Ld_ret_20);
}

int getGmtShift() {
   int Lia_unused_0[4];
   int Lia_4[43];
   int Li_8 = 0;
   int Li_12 = GetTimeZoneInformation(Lia_4);
   if (Li_12 != 0) Li_8 = Lia_4[0];
   if (Li_12 == 2) Li_8 += Lia_4[42];
   return (Li_8 / 60);
}

int TimeGmt() {
   return (TimeLocal() + 60 * (60 * getGmtShift()));
}

int getGmtHour(int Ai_0 = 0) {
   if (IsTesting()) return (TimeHour(TimeCurrent()) - Ai_0);
   int hour_4 = TimeHour(TimeLocal());
   return (MathMod(hour_4 + getGmtShift(), 24) + Ai_0);
}

int is5Digit() {
   return (Digits == 3 || Digits == 5);
}

double getSpread() {
   double Ld_0 = 1;
   if (is5Digit()) Ld_0 = 10.0;
   return (MarketInfo(Symbol(), MODE_SPREAD) / Ld_0);
}

string getSpreadStr() {
   return (DoubleToStr(getSpread(), 2));
}

int tradeRange(int Ai_0, int Ai_4, int Ai_8, int Ai_12) {
   bool Li_16;
   if (IsTesting()) Li_16 = Ai_12;
   else Li_16 = FALSE;
   int Li_20 = getGmtHour(Li_16);
   int day_of_week_24 = TimeDayOfWeek(TimeGmt());
   if (Ai_0 > Ai_4) {
      Ai_4 += 24;
      if (Li_20 < Ai_0) Li_20 += 24;
   }
   if (day_of_week_24 == 5 && MathMod(Li_20, 24) >= Ai_0) {
      Ai_4 = 19;
      Ai_8 = 1;
   }
   if (Li_20 >= Ai_0 && Li_20 < Ai_4) return (1);
   if (Li_20 >= Ai_4 && MathMod(Li_20, 24) < MathMod(Ai_4 + Ai_8, 24)) return (2);
   if (MathMod(Li_20, 24) > MathMod(Ai_4 + Ai_8, 24)) return (3);
   if (day_of_week_24 == 5 && getGmtHour() >= 20 && TimeMinute(TimeLocal()) > 45) return (0);
   return (0);
}

int isSunday(int Ai_0) {
   int Li_4 = getGmtHour();
   int Li_8 = getDay();
   if (Li_8 == 0 || (Li_8 == 1 && Li_4 < Ai_0)) return (1);
   return (0);
}

int getDay() {
   return (TimeDayOfWeek(TimeGmt()));
}

int getOrderCount(int A_magic_0) {
   int count_4 = 0;
   int order_total_8 = OrdersTotal();
   for (int pos_12 = 0; pos_12 < order_total_8; pos_12++) {
      if (OrderSelect(pos_12, SELECT_BY_POS, MODE_TRADES) != FALSE)
         if (OrderMagicNumber() == A_magic_0 && OrderSymbol() == Symbol() && OrderType() == OP_BUY || OrderType() == OP_SELL) count_4++;
   }
   return (count_4);
}

void modifyOrder(int A_magic_0, int Ai_4) {
   int order_total_8;
   double Ld_12;
   if (Ai_4) {
      order_total_8 = OrdersTotal();
      Ld_12 = Point * Ai_4;
      for (int pos_20 = 0; pos_20 < order_total_8; pos_20++) {
         if (OrderSelect(pos_20, SELECT_BY_POS, MODE_TRADES) != FALSE) {
            if (OrderMagicNumber() == A_magic_0 && OrderSymbol() == Symbol()) {
               if (OrderType() == OP_SELL) {
                  if (OrderOpenPrice() - Ask > Ld_12) {
                     if (OrderStopLoss() > Ask + Ld_12 || OrderStopLoss() == 0.0) {
                        OrderModify(OrderTicket(), OrderOpenPrice(), Ask + Ld_12, OrderTakeProfit(), 0, Red);
                        return;
                     }
                  }
               }
               if (OrderType() == OP_BUY) {
                  if (Bid - OrderOpenPrice() > Ld_12) {
                     if (OrderStopLoss() < Bid - Ld_12) {
                        OrderModify(OrderTicket(), OrderOpenPrice(), Bid - Ld_12, OrderTakeProfit(), 0, Green);
                        return;
                     }
                  }
               }
            }
         }
      }
   }
}

void changeTP(int A_magic_0, double A_price_4) {
   int order_total_12 = OrdersTotal();
   for (int pos_16 = 0; pos_16 < order_total_12; pos_16++) {
      if (OrderSelect(pos_16, SELECT_BY_POS, MODE_TRADES) != FALSE) {
         if (OrderMagicNumber() == A_magic_0 && OrderSymbol() == Symbol())
            if (!(OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), A_price_4, 0, Green))) break;
      }
   }
}

void closeOrders(int A_magic_0) {
   int order_total_4 = OrdersTotal();
   double price_8 = 0;
   int Li_unused_16 = 290000;
   for (int pos_20 = 0; pos_20 < order_total_4; pos_20++) {
      if (OrderSelect(pos_20, SELECT_BY_POS, MODE_TRADES) != FALSE) {
         if (OrderSymbol() == Symbol() && OrderMagicNumber() == A_magic_0) {
            if (OrderType() == OP_SELL) price_8 = Ask;
            else
               if (OrderType() == OP_BUY) price_8 = Bid;
            OrderClose(OrderTicket(), OrderLots(), price_8, 3, Violet);
            switch (OrderType()) {
            case OP_BUYLIMIT:
            case OP_BUYSTOP:
            case OP_SELLLIMIT:
            case OP_SELLSTOP:
               OrderDelete(OrderTicket());
            }
            Sleep(1000);
         }
      }
   }
}

void reduceProfit(int A_magic_0, int Ai_4) {
   int Li_28;
   int Li_8 = Ai_4;
   double price_12 = 0;
   int order_total_20 = OrdersTotal();
   for (int pos_24 = 0; pos_24 < order_total_20; pos_24++) {
      if (OrderSelect(pos_24, SELECT_BY_POS, MODE_TRADES) != FALSE) {
         Li_28 = (TimeCurrent() - OrderOpenTime()) / 300;
         if (OrderSymbol() == Symbol() && OrderMagicNumber() == A_magic_0 && OrderProfit() < 0.0 && Li_28 != Gi_76) {
            if (OrderType() == OP_BUY) price_12 = OrderTakeProfit() - Li_8 * Point;
            if (OrderType() == OP_SELL) price_12 = OrderTakeProfit() + Li_8 * Point;
            OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), price_12, 0, Green);
            Gi_76 = Li_28;
         }
      }
   }
}

void closeOrdersOp(int A_magic_0, int A_cmd_4) {
   int order_total_8 = OrdersTotal();
   double price_12 = 0;
   int Li_unused_20 = 290000;
   for (int pos_24 = 0; pos_24 < order_total_8; pos_24++) {
      if (OrderSelect(pos_24, SELECT_BY_POS, MODE_TRADES) != FALSE) {
         if (OrderSymbol() == Symbol() && OrderMagicNumber() == A_magic_0 && OrderType() == A_cmd_4) {
            switch (OrderType()) {
            case OP_BUYLIMIT:
            case OP_BUYSTOP:
            case OP_SELLLIMIT:
            case OP_SELLSTOP:
               OrderDelete(OrderTicket());
            }
            if (OrderType() == OP_SELL) price_12 = Ask;
            else price_12 = Bid;
            OrderClose(OrderTicket(), OrderLots(), price_12, 3, Violet);
         }
      }
   }
}

double getAtr(string A_symbol_0, int A_timeframe_8 = 60, int A_period_12 = 20) {
   return (iATR(A_symbol_0, A_timeframe_8, A_period_12, 0) / MarketInfo(A_symbol_0, MODE_POINT));
}

int boll(int A_timeframe_0 = 0) {
   if (iBands(NULL, A_timeframe_0, 20, 2, 0, PRICE_CLOSE, MODE_LOWER, 0) > Close[0]) return (1);
   if (iBands(NULL, A_timeframe_0, 20, 2, 0, PRICE_CLOSE, MODE_UPPER, 0) < Close[0]) return (-1);
   return (0);
}

int sar(int A_timeframe_0 = 0) {
   if (iSAR(NULL, A_timeframe_0, 0.02, 0.2, 0) < Close[0]) return (1);
   if (iSAR(NULL, A_timeframe_0, 0.02, 0.2, 0) > Close[0]) return (-1);
   return (0);
}

void TrailingStop(int A_magic_0, bool Ai_4 = TRUE, bool Ai_8 = TRUE) {
   int cmd_12;
   int ticket_16;
   bool bool_20;
   double Ld_24;
   double order_stoploss_32;
   double order_open_price_40;
   string symbol_52;
   double digits_60;
   double ask_68;
   double bid_76;
   for (int pos_48 = 0; pos_48 < OrdersTotal(); pos_48++) {
      if (OrderSelect(pos_48, SELECT_BY_POS) == TRUE) {
         cmd_12 = OrderType();
         if (cmd_12 < OP_BUYLIMIT && OrderMagicNumber() == A_magic_0) {
            symbol_52 = OrderSymbol();
            digits_60 = MarketInfo(OrderSymbol(), MODE_DIGITS);
            ask_68 = MarketInfo(OrderSymbol(), MODE_ASK);
            bid_76 = MarketInfo(OrderSymbol(), MODE_BID);
            order_stoploss_32 = OrderStopLoss();
            order_open_price_40 = OrderOpenPrice();
            ticket_16 = OrderTicket();
            if (cmd_12 == OP_BUY) {
               Ld_24 = TrailOrderFrac(symbol_52, 1, bid_76);
               if (Ld_24 <= order_open_price_40 && Ai_4) continue;
               if (order_stoploss_32 >= order_open_price_40 && Ai_8) continue;
               if (Ld_24 > order_stoploss_32) {
                  bool_20 = OrderModify(ticket_16, order_open_price_40, NormalizeDouble(Ld_24, digits_60), OrderTakeProfit(), 0, White);
                  Sleep(500);
                  if (!bool_20) Print("Error order ", ticket_16, " TrailingStop ", GetLastError(), "   ", symbol_52, "   SL ", Ld_24);
               }
            }
            if (cmd_12 == OP_SELL) {
               Ld_24 = TrailOrderFrac(symbol_52, -1, ask_68);
               if (Ld_24 != 0.0) {
                  if (Ld_24 >= order_open_price_40 && Ai_4) continue;
                  if (order_stoploss_32 >= order_open_price_40 && Ai_8) continue;
                  if (Ld_24 < order_stoploss_32 || order_stoploss_32 == 0.0) {
                     bool_20 = OrderModify(ticket_16, order_open_price_40, NormalizeDouble(Ld_24, digits_60), OrderTakeProfit(), 0, White);
                     Comment("TrailingStop " + ticket_16, " ", TimeToStr(TimeCurrent(), TIME_MINUTES));
                     Sleep(500);
                     if (!bool_20) Print("Error order ", ticket_16, " TrailingStop ", GetLastError(), "   ", symbol_52, "   SL ", Ld_24);
                  }
               }
            }
         }
      }
   }
}

double TrailOrderFrac(string A_symbol_0, int Ai_8, double Ad_12, int A_timeframe_20 = 30) {
   double ifractals_24;
   double pips_32 = 0;
   int Li_40 = 50;
   double point_44 = MarketInfo(A_symbol_0, MODE_POINT);
   if (Ai_8 == 1) {
      for (int Li_52 = 1; Li_52 < Li_40; Li_52++) {
         ifractals_24 = iFractals(A_symbol_0, A_timeframe_20, MODE_LOWER, Li_52);
         if (ifractals_24 != 0.0) {
            if (Ad_12 - pips_32 * point_44 > ifractals_24) break;
            ifractals_24 = 0;
         }
      }
   }
   if (Ai_8 == -1) {
      for (int Li_56 = 1; Li_56 < Li_40; Li_56++) {
         ifractals_24 = iFractals(NULL, 0, MODE_UPPER, Li_56);
         if (ifractals_24 != 0.0) {
            if (Ad_12 + pips_32 * point_44 < ifractals_24) break;
            ifractals_24 = 0;
         }
      }
   }
   return (ifractals_24);
}

int init() {
   ArrayResize(Gda_180, SlidingWindow);
   if (!IsTesting()) Offset = TimeHour(TimeCurrent()) - getGmtHour();
   int day_of_week_0 = TimeDayOfWeek(TimeGmt());
   if (day_of_week_0 == 0 && TradeOnSunday == FALSE) {
      Comment("Trading disabled on sunday .");
      return (0);
   }
   Gs_216 = TerminalPath() + "//experts//files";
   initAnn();
   double close_4 = Close[1];
   if (AutoAdjustDigits && Digits == 3 || Digits == 5) {
      Print("multiplying ");
      TakeProfit = 10 * TakeProfit;
      Trail = 10 * Trail;
      Stop = 10 * Stop;
      Gi_260 = 10 * Gi_260;
      Threshhold = 10 * Threshhold;
      RiskReducer = 10 * RiskReducer;
   }
   if (close_4 < 1.0) Gd_196 = 1;
   if (close_4 < 10.0) Gd_196 = 0.1;
   if (close_4 > 10.0 && close_4 < 100.0) Gd_196 = 0.01;
   if (close_4 > 100.0 && close_4 < 1000.0) Gd_196 = 0.001;
   return (0);
}

void initAnn() {
   if (Gi_184 == 0) {
      Gi_184 = CreateAnn();
      f2M_parallel_init();
   }
}

int start() {
   int Li_ret_0 = perform();
   Comment(Gs_284);
   return (Li_ret_0);
}

int perform() {
   double price_16;
   initAnn();
   Gs_284 = "---" + Gs_80 + "--\n";
   int Li_0 = getOrderCount(MAGIC_NUM);
   double iforce_4 = iForce(NULL, PERIOD_M15, 6, MODE_EMA, PRICE_CLOSE, 0);
   int index_12 = 0;
   if (Li_0 > 0) {
      if (TrailFractal) TrailingStop(MAGIC_NUM);
      else {
         price_16 = 1.0 / Gd_196 * f2M_get_output(Gi_184, 0);
         modifyOrder(MAGIC_NUM, Trail);
      }
   }
   int day_of_week_24 = TimeDayOfWeek(TimeGmt());
   if (day_of_week_24 != G_day_of_week_292) G_count_268 = 0;
   G_day_of_week_292 = day_of_week_24;
   if (!doTimeFilter(day_of_week_24)) return (0);
   if (MathAbs(iforce_4) > ForceIndex) {
      addComment("Force is: " + iforce_4 + ", waiting for force to get below " + ForceIndex);
      return (0);
   }
   int Li_28 = TimeMinute(Time[0]) / 5;
   if (G_time_192 != Time[0]) Gi_272 = FALSE;
   if (G_time_192 == Time[0]) {
      if ((!ContinuousMode) && Gi_272) return (0);
   } else trainNN();
   if (Gi_272) G_time_192 = Time[0];
   Gi_unused_212 = Li_28;
   for (index_12 = 0; index_12 < SlidingWindow; index_12++) Gda_180[index_12] = Close[SlidingWindow - index_12];
   int Li_32 = f2M_run(Gi_184, Gda_180);
   if (Li_32 < 0) {
      debug(0, "Network RUN ERROR! ann=" + Gi_184);
      return (-1000000000);
   }
   price_16 = 1.0 / Gd_196 * f2M_get_output(Gi_184, 0);
   price_16 = NormalizeDouble(price_16, Digits);
   double Ld_36 = f2M_get_MSE(Gi_184);
   if (Ld_36 >= 0.0) {
      setMissingTP(MAGIC_NUM, price_16, price_16);
      Gs_284 = StringConcatenate(Gs_284, 
         "\n Spread :" + getSpreadStr() 
         + "\n SL :" + Gs_276 
      + "\nNext Target: " + DoubleToStr(price_16, Digits) + " mse " + Ld_36);
   }
   ObjectDelete("text_object");
   ObjectCreate("text_object", OBJ_HLINE, 0, TimeCurrent(), price_16);
   if (Li_0 < Gi_208) {
      placeOrders(price_16);
      if (Li_0 == 1) manageOrders(price_16);
   } else manageOrders(price_16);
   return (0);
}

void addComment(string As_0) {
   Gs_284 = StringConcatenate(Gs_284, 
      "\n" 
   + As_0);
}

int CreateAnn() {
   Gi_184 = f2M_create_standard(4, SlidingWindow, 12, 18, 1);
   f2M_set_act_function_hidden(Gi_184, 6);
   f2M_set_act_function_output(Gi_184, 6);
   f2M_randomize_weights(Gi_184, -0.4, 0.4);
   debug(1, "ANN: \'" + "\' created successfully with handler " + Gi_184);
   if (Gi_184 == -1) debug(0, "ERROR INITIALIZING NETWORK!");
   return (Gi_184);
}

int trainNN() {
   int Li_16;
   double Ld_0 = 1;
   while (Ld_0 > MinMSE || G_count_268 < Epochs && G_count_268 < MaxEpochs) {
      for (int Li_8 = Gi_204; Li_8 >= SlidingWindow + 1; Li_8--) {
         for (int index_12 = 0; index_12 < SlidingWindow; index_12++) Gda_180[index_12] = Close[Li_8 - index_12];
         AnnTrain(Close[Li_8 - index_12 - 1]);
      }
      Li_16 = f2M_run(Gi_184, Gda_180);
      Ld_0 = f2M_get_MSE(Gi_184);
      G_count_268++;
      Comment("Training neural net ....: MSE:  " + Ld_0 + ":" + G_count_268);
   }
   return (0);
}

void debug(int Ai_0, string As_4) {
   if (Ai_0 == 0) As_4 = "ERROR: " + As_4;
   Print(As_4);
}

void AnnTrain(double Ad_0) {
   double Lda_8[1];
   Lda_8[0] = Ad_0 * Gd_196;
   if (f2M_train(Gi_184, Gda_180, Lda_8) == -1) debug(0, "Network TRAIN ERROR! ann=" + Gi_184);
}

int deinit() {
   ann_destroy();
   f2M_parallel_deinit();
   return (0);
}

void manageOrders(double Ad_0) {
   double order_takeprofit_16;
   double Ld_24;
   int order_total_8 = OrdersTotal();
   for (int pos_12 = 0; pos_12 < order_total_8; pos_12++) {
      if (OrderSelect(pos_12, SELECT_BY_POS, MODE_TRADES) != FALSE) {
         if (OrderMagicNumber() == MAGIC_NUM && OrderSymbol() == Symbol()) {
            order_takeprofit_16 = OrderTakeProfit();
            Ld_24 = 30.0 * Point;
            if (OrderProfit() < 0.0) break;
            if (OrderType() == OP_BUY) {
               if (Ad_0 < OrderTakeProfit() && Ad_0 > OrderOpenPrice()) {
                  changeTP(MAGIC_NUM, Ad_0);
                  Sleep(20000);
               }
            }
            if (OrderType() == OP_SELL) {
               if (Ad_0 > OrderTakeProfit() && Ad_0 < OrderOpenPrice()) {
                  changeTP(MAGIC_NUM, Ad_0);
                  Sleep(20000);
               }
            }
         }
      }
   }
}

void placeOrders(double Ad_0) {
   double Ld_8 = Threshhold * Point;
   int Li_16 = getOrderCount(MAGIC_NUM);
   double Ld_unused_20 = 0;
   if (Close[3] > Close[2] && Close[2] > Close[1]) Ld_unused_20 = -1;
   if (Close[3] < Close[2] && Close[2] < Close[1]) Ld_unused_20 = 1;
   Ld_unused_20 = sar();
   int Li_28 = boll();
   if (Ad_0 > Ask + Ld_8 && Li_28 >= 0) {
      closeOrdersOp(MAGIC_NUM, OP_SELL);
      placeOrderL(0, Ad_0);
   }
   if (Ad_0 < Bid - Ld_8 && Li_28 <= 0) {
      closeOrdersOp(MAGIC_NUM, OP_BUY);
      placeOrderL(1, Ad_0);
   }
}

void placeOrderL(int Ai_0, double Ad_4) {
   double pips_32;
   double Ld_40;
   double Ld_48;
   int ticket_12 = 0;
   int Li_unused_16 = 0;
   int Li_20 = getOrderCount(MAGIC_NUM);
   double lots_24 = Lots;
   Gi_272 = TRUE;
   if (UseMoneyManagement) lots_24 = getLots(RiskFactor, UseMoneyManagement, Lots);
   if (Li_20 <= 0) {
      pips_32 = getAtr(Symbol());
      if (Ai_0 == 0) {
         Ad_4 = MathMax(Ad_4, Ask + pips_32 * Point);
         ticket_12 = OrderSend(Symbol(), OP_BUY, lots_24, Ask, 3, 0, 0, Gs_80 + getTimeFrame(), MAGIC_NUM, 0, Purple);
         Ld_40 = Low[iLowest(NULL, 0, MODE_LOW, Gi_188, 0)];
         Ld_48 = Bid - Stop * Point;
         if (Ld_40 < Ld_48 || Gi_188 == WHOLE_ARRAY) {
            Ld_40 = Ld_48;
            Gs_276 = "SL set to min SL: " + Stop;
         }
         setSL(MAGIC_NUM, Ld_40);
         changeTP(MAGIC_NUM, Ad_4);
      } else {
         if (Ai_0 == 1) {
            Ad_4 = MathMax(Ad_4, Bid - pips_32 * Point);
            ticket_12 = OrderSend(Symbol(), OP_SELL, lots_24, Bid, 3, 0, 0, Gs_80 + getTimeFrame(), MAGIC_NUM, 0, Yellow);
            Ld_40 = High[iHighest(NULL, 0, MODE_HIGH, Gi_188, 0)];
            Ld_48 = Ask + Stop * Point;
            if (Ld_40 > Ld_48 || Gi_188 == WHOLE_ARRAY) {
               Ld_40 = Ld_48;
               Gs_276 = "SL set to min SL: " + Stop;
            }
            setSL(MAGIC_NUM, Ld_40);
            changeTP(MAGIC_NUM, Ad_4);
         }
      }
   }
}

int setMissingTP(int A_magic_0, double Ad_unused_4, double Ad_unused_12) {
   bool Li_ret_20 = FALSE;
   int order_total_24 = OrdersTotal();
   for (int pos_28 = 0; pos_28 < order_total_24; pos_28++) {
      if (OrderSelect(pos_28, SELECT_BY_POS, MODE_TRADES) != FALSE) {
         if (OrderMagicNumber() == A_magic_0 && OrderSymbol() == Symbol() && OrderTakeProfit() == 0.0 || MathAbs(OrderTakeProfit() - OrderOpenPrice()) > 0.3) {
            if (OrderType() == OP_BUY) OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), Ask + TakeProfit * Point, 0, Green);
            if (OrderType() == OP_SELL) OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), Bid - TakeProfit * Point, 0, Green);
         }
      }
   }
   return (Li_ret_20);
}

int setSL(int A_magic_0, double A_price_4) {
   int order_total_12 = OrdersTotal();
   for (int pos_16 = 0; pos_16 < order_total_12; pos_16++) {
      if (OrderSelect(pos_16, SELECT_BY_POS, MODE_TRADES) != FALSE)
         if (OrderMagicNumber() == A_magic_0 && OrderSymbol() == Symbol() && OrderStopLoss() == 0.0) OrderModify(OrderTicket(), OrderOpenPrice(), A_price_4, OrderTakeProfit(), 0, Green);
   }
   return (0);
}

bool doTimeFilter(int Ai_unused_0) {
   bool Li_24;
   int hour_28;
   int Li_32;
   int Li_4 = EndHour;
   bool Li_ret_8 = FALSE;
   if ((!TradeOnSunday) && isSunday(BeginHour)) {
      printComment(" Trading disabled on sunday ... ");
      return (Li_ret_8);
   }
   int Li_12 = tradeRange(BeginHour, Li_4, CloseAfter, Offset);
   if (!TimeFilter) {
      printComment(" TimFilter off ");
      return (TRUE);
   }
   string Ls_16 = "\nLots:" + Lots + " ";
   if (Li_12 == 1) {
      Ls_16 = " \nReady to trade \n Trade Range " + BeginHour + ":00 - " + EndHour + ":00 GMT ";
      Li_ret_8 = TRUE;
   } else {
      if (Li_12 == 3) {
         if (IsTesting()) Li_24 = Offset;
         else Li_24 = FALSE;
         hour_28 = TimeHour(getGmtHour(Li_24));
         Ls_16 = hour_28 + " Closing all open trades -  Trading will begin at GMT:";
         Ls_16 = Ls_16 
            + "\n" 
         + BeginHour + ":00 and continue until " + EndHour + ":00";
         closeOrders(MAGIC_NUM);
      } else {
         if (Li_12 == 2) {
            Ls_16 = "\nRedcuing TP by " + RiskReducer;
            reduceProfit(MAGIC_NUM, RiskReducer);
         } else {
            Ls_16 = "  Trading will begin at GMT:";
            Ls_16 = Ls_16 
               + "\n" 
            + BeginHour + ":00 and continue until " + EndHour + ":00";
            Li_32 = getOrderCount(MAGIC_NUM);
            if (Li_32 > 0) closeOrders(MAGIC_NUM);
         }
      }
   }
   printComment(Ls_16);
   return (Li_ret_8);
}

void printComment(string As_0) {
   Gs_284 = StringConcatenate(Gs_284, "Traded:" + Gi_272 
   + "\nNow is GMT : " + getTime() + " \n" + As_0 + " \n \n GMT Offset: " + Offset);
}

string getTime() {
   int minute_0 = TimeMinute(TimeLocal());
   string Ls_4 = "" + minute_0;
   if (minute_0 < 10) Ls_4 = "0" + Ls_4;
   return (getGmtHour() + ":" + Ls_4);
}

void ann_destroy() {
   int Li_0 = -1;
   Li_0 = f2M_destroy(Gi_184);
   debug(1, "f2M_destroy(" + Gi_184 + ") returned: " + Li_0);
}