#property copyright "Maxou888"
#property link      ""
#include <WinUser32.mqh>
#include <stdlib.mqh>
#define  NL    "\n"

//---- input parameters
extern string     PairsToTrade="EURAUD,EURCAD,EURCHF,EURGBP,EURJPY,EURNZD,EURUSD,AUDJPY,CADJPY,CHFJPY,GBPJPY,NZDJPY,USDJPY,AUDUSD,GBPUSD,NZDUSD,USDCAD,USDCHF";

extern string s000     = "--------- Filters"; 
extern bool       UseEconomicNewsFilter=false; 
extern string s010     = "1=Normal, 2=1+UseKGmode, 3=JPYRollercoster "; 
extern int        EAMode               =1;
extern string s001     = "--------- General"; 
extern bool       SingleSymbol         =false; // if true, use PairsToTrade; if false use chart symbol for backtesting 
extern double     InitialLot           =0.60;
extern double     StartLotScal         =0.3;
extern double     Increament           =0.3;
extern int        MaxLotsPerPair       =30;
extern int        UseMartinguale       =1;
extern int        IncreaseAutoAtMartin =1;
extern int        IncreaseWithSignalForce=1;
extern string s002     = "--------- TS & BE"; 
extern int        TSOnTrades           =0;
extern int        TSOnScale            =0;
extern int        TSOnHedge            =0;
extern int        BreakEvenOnTrades    =1;
extern int        BreakEvenOnScale     =1;
extern int        BreakEvenOnHedges    =1;
extern string s003     = "--------- Closing"; 
extern int        CloseByOppInProfit   =1;
extern bool       CloseByOppKG         =false; 
int               MinTradesForEasyClose=4;
extern string s004     = "--------- Hedge"; 
extern int        HedgeEnable          =0;
extern double     AccountLossForHedging=4000;
extern int        larguagrhedgeOnSig   =0;
extern string s005     = "--------- KG"; 
double            UpTrig               =75;
double            LoTrig               =25;

int       InitialBreakEvenPips     =200;//15 
double    OptimTarget              =1.0;
int       rsi_period_smooth        =4;
bool      AccountInEuro            =true;
double    EurValueForBT            =1.47;
int       InitialMinDistance       =200;
int       InitialMinDistanceScal   =100;
bool      UseKGmode                =false; 
bool      UseKGmodeJPYRollercoster =false; 


int       jump                     =30;
int       EAMagic                  = 400944;

color     LongC1                 = DodgerBlue;
color     ShortC1                = MediumOrchid;
color     LongHedge              = SteelBlue;
color     ShortHedge             = SteelBlue;
color     LongTrade              = LimeGreen;
color     ShortTrade             = Red;
color     ColCloseByOpp          = Magenta;
color     colclosebyProfitCycle  = Chocolate;
color     ColCurrencyBasket      = Silver;
color     ColBasket          = Black;

int       magic,magicT,magicS,magicH;
int       period0,period1up,period2up;
string    ComT,ComH,ComS,com;
double    point, vpoint,maxlot,minlot,m2Lot,hLot,CurrencyProfit;
double    StartLot,stoplevel,TickValue,EurValue; 
int       prec=0,Mdig=1,MinDistance,MinDistanceScal;
double    TOTTrade, LOTTrade,PRICETrade;
double    TOTHedge,LOTHedge,TOTScale; 
int       TYPETrade,TYPEHedge,TYPEScale;   
int       Target,dist,LastTradeOpenTime,LastScaleOpenTime,LastHedgeOpenTime,cpt;  
double    BigTarget,BasketTarget,CurrencyTarget,ThisTimeTarget,coefP;
double    EURTotTrades,GBPTotTrades,CADTotTrades,JPYTotTrades,CHFTotTrades,USDTotTrades,AUDTotTrades,NZDTotTrades,BasketTotTrades;
double    EURTotLots,GBPTotLots,CADTotLots,JPYTotLots,CHFTotLots,USDTotLots,AUDTotLots,NZDTotLots,BasketTotLots;
int       BreakEvenPips,TrailingStop;
int       Signal_Strong,Signal_Light;
double    SMA_TF0,SMA_TF1up,rsi_smooth_TF1up;
double    EMA_TF0_20,EMA_TF0_200,EMA_TF1_20,EMA_TF1_200,EMA_TF2_20,EMA_TF2_200;
double    TotLongs, TotShorts;
double    RsiTF0_rsi,      RsiTF0_UpB,       RsiTF0_LoB;
double    RsiTF0_rsi_OLD,  RsiTF0_UpB_OLD,   RsiTF0_LoB_OLD;
double    RsiTF1up_rsi,    RsiTF1up_UpB,     RsiTF1up_LoB;
double    RsiTF1up_rsi_OLD,RsiTF1up_UpB_OLD, RsiTF1up_LoB_OLD;
double    RsiTF0_rsiMax,   RsiTF0_rsiMin,    RsiTF1up_rsiMax,   RsiTF1up_rsiMin;
double    rsi,RsiMax,RsiMin;
bool      OKforOpen;
int       KgStatus=0;
double    JpyKgRS,UsdKgRS,GbpKgRS,EurKgRS,ChfKgRS,AudKgRS,NzdKgRS,CadKgRS;

//Pair extraction
string            InputString;//Holds the contents PairsToTrade for tidying yp etc
int               NoOfPairs;// Holds the number of pairs passed by the user via the inputs screen
string            TradePair[]; //Array to hold the pairs traded by the user
string            Pair;
int               cc;
double            ask, bid,digits;
string            ScreenMessage,Gap,mode="",Text="";
// Trailing Stop
int       InitialTrailingStop = 20; 

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   if (EAMode==1)
   {
      PairsToTrade="AUDCAD,AUDCHF,AUDJPY,AUDNZD,AUDUSD,CADCHF,CADJPY,CHFJPY,EURAUD,EURCAD,EURCHF,EURGBP,EURJPY,EURUSD,GBPCHF,GBPJPY,GBPUSD,NZDJPY,NZDUSD,SGDJPY,USDCAD,USDCHF,USDDKK,USDHKD,USDJPY,USDNOK,USDSEK";
      UseKGmode=false;
      UseKGmodeJPYRollercoster=false;
      mode="NO.";
      StartLot=InitialLot;
      EAMagic=EAMagic;
   }
   if (EAMode==2)
   {
      PairsToTrade="AUDCAD,AUDCHF,AUDJPY,AUDNZD,AUDUSD,CADCHF,CADJPY,CHFJPY,EURAUD,EURCAD,EURCHF,EURGBP,EURJPY,EURUSD,GBPCHF,GBPJPY,GBPUSD,NZDJPY,NZDUSD,USDCHF,USDJPY,USDCAD";
      UseKGmode=true;
      UseKGmodeJPYRollercoster=false;
      mode="KG.";
      EAMagic=EAMagic+1000;
      StartLot=InitialLot*1.5;
      if(CloseByOppKG==true)   StartLot=InitialLot*2;

   }
   if (EAMode==3)
   {
      PairsToTrade="AUDJPY,CADJPY,CHFJPY,EURJPY,GBPJPY,NZDJPY,USDJPY";
      UseKGmode=true;
      UseKGmodeJPYRollercoster=true;
      mode="YY.";
      CloseByOppKG         =true; 
      EAMagic=EAMagic+3000;
      StartLot       =InitialLot*2.5;
      StartLotScal   =StartLotScal*1.5;
      Increament     =Increament*1.5;
   }

   string txt="";
   if (Period()==PERIOD_M5)
   {
      period0  =PERIOD_M5 ;
      period1up=PERIOD_M15;
      period2up=PERIOD_H1;
      coefP    =0.5;
      txt="M5.";
   }
   if (Period()==PERIOD_M15)
   {
      period0  =PERIOD_M15 ;
      period1up=PERIOD_H1;
      period2up=PERIOD_H4;
      coefP    =0.7;
      txt="M15.";
   }
   if (Period()==PERIOD_H1)
   {
      period0  =PERIOD_H1 ;
      period1up=PERIOD_H4;
      period2up=PERIOD_D1;
      coefP    =1;
      txt="H1.";
   }
   // ================  LOOP FOR PAIR TO TRADE
   //Extract the pairs traded by the user
   // Cleanup first
   int cc;
   //Extract the pairs traded by the user
   // Cleanup first
   NoOfPairs=0;
   InputString=PairsToTrade;
   CleanUpInputString();
   
   // Extract the number of paraaters passed by the user
   CalculatePairsPassed();
   string AddChar = StringSubstr(Symbol(),6,4);
   
   // Resize the array appropriately
   string NewArray = ArrayResize(TradePair, NoOfPairs);
   
   int Index = 0;//For searching InputString
   int LastIndex = 0;//Points the the most recent Index
   for (cc = 0; cc < NoOfPairs; cc ++)
   {
      Index = StringFind(InputString, ",",LastIndex);
      if (Index > -1)
      {
         TradePair[cc] = StringSubstr(InputString, LastIndex,Index-LastIndex);
         TradePair[cc] = StringTrimLeft(TradePair[cc]);
         TradePair[cc] = StringTrimRight(TradePair[cc]);
         TradePair[cc] = StringConcatenate(TradePair[cc], AddChar);
         
         LastIndex = Index+1;
         
      }//if (Index > -1)            
   }//for (int cc; cc<NoOfPairs; cc ++)
   // =============  END LOOP FOR PAIR TO TRADE

   ComT =mode+"T."+txt;
   ComH =mode+"H."+txt;
   ComS =mode+"S."+txt;

   magicT           =EAMagic; // Trade
   magicH           =magicT+100;      // Hedge
   magicS           =magicT+200;      // Scaling
  
return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
   Comment("");
   return(0);
}
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//X                               S  T  A  R  T                                                           X
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
int start()
{
   if(SingleSymbol==false)
   {  //Loop around the pairs list
      for (int cc = 0; cc < NoOfPairs; cc++)
      {
         ask = MarketInfo(TradePair[cc], MODE_ASK);
         bid = MarketInfo(TradePair[cc], MODE_BID);
         digits = MarketInfo(TradePair[cc], MODE_DIGITS);
         point = MarketInfo(TradePair[cc], MODE_POINT);
         Pair=TradePair[cc];

         DoProgramm (); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< M A I N     P R O G R A M M
      }//for (cc = 0; cc < NoOfPairs; cc==)
   }//if(SingleSymbol==false)
   else
   {
      ask=Ask;
      bid=Bid;
      digits= Digits;
      point=Point;
      Pair=Symbol();
      DoProgramm (); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< M A I N     P R O G R A M M
   }

   //=========================================================================================================
   //=                        Basket Controls                                                                =
   //=========================================================================================================
      CurrencyTarget =coefP*800*StartLot;
      
      if (UseKGmodeJPYRollercoster==true){BasketTarget=coefP*120*StartLot;} else {BasketTarget=coefP*1200*StartLot;}
      EURTotLots  =BasketLOT("EUR");
      GBPTotLots  =BasketLOT("GBP");
      CADTotLots  =BasketLOT("CAD");
      JPYTotLots  =BasketLOT("JPY");
      CHFTotLots  =BasketLOT("CHF");
      USDTotLots  =BasketLOT("USD");
      AUDTotLots  =BasketLOT("AUD");
      NZDTotLots  =BasketLOT("NZD");
      BasketTotLots    = EURTotLots+GBPTotLots+CADTotLots+JPYTotLots+CHFTotLots+USDTotLots+AUDTotLots+NZDTotLots;

   //******************************************
   //      Currency Basket   CurrencyTarget   *
   //******************************************
 /*     if (EURTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("EUR")>=CurrencyTarget)  CloseBasket("EUR");}  
      if (GBPTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("GBP")>=CurrencyTarget)  CloseBasket("GBP");}  
      if (CADTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("CAD")>=CurrencyTarget)  CloseBasket("CAD");}  
      if (JPYTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("JPY")>=CurrencyTarget)  CloseBasket("JPY");}  
      if (CHFTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("CHF")>=CurrencyTarget)  CloseBasket("CHF");}  
      if (USDTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("USD")>=CurrencyTarget)  CloseBasket("USD");}  
      if (AUDTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("AUD")>=CurrencyTarget)  CloseBasket("AUD");}  
      if (NZDTotLots>=MaxLotsPerPair)  {if (CurrencyProfit("NZD")>=CurrencyTarget)  CloseBasket("NZD");}  
   */
   if (UseKGmodeJPYRollercoster==false)
   {  if (CurrencyProfit("EUR")>=CurrencyTarget)  {CloseBasket("EUR"); Alert(mode,"Basket EUR cl @", DoubleToStr(CurrencyProfit("EUR"),1));}
      if (CurrencyProfit("GBP")>=CurrencyTarget)  {CloseBasket("GBP"); Alert(mode,"Basket GBP cl @", DoubleToStr(CurrencyProfit("GBP"),1));}
      if (CurrencyProfit("CAD")>=CurrencyTarget)  {CloseBasket("CAD"); Alert(mode,"Basket CAD cl @", DoubleToStr(CurrencyProfit("CAD"),1));}  
      if (CurrencyProfit("JPY")>=CurrencyTarget)  {CloseBasket("JPY"); Alert(mode,"Basket JPY cl @", DoubleToStr(CurrencyProfit("JPY"),1));} 
      if (CurrencyProfit("CHF")>=CurrencyTarget)  {CloseBasket("CHF"); Alert(mode,"Basket CHF cl @", DoubleToStr(CurrencyProfit("CHF"),1));}  
      if (CurrencyProfit("USD")>=CurrencyTarget)  {CloseBasket("USD"); Alert(mode,"Basket USD cl @", DoubleToStr(CurrencyProfit("USD"),1));} 
      if (CurrencyProfit("AUD")>=CurrencyTarget)  {CloseBasket("AUD"); Alert(mode,"Basket AUD cl @", DoubleToStr(CurrencyProfit("AUD"),1));}  
      if (CurrencyProfit("NZD")>=CurrencyTarget)  {CloseBasket("NZD"); Alert(mode,"Basket NZD cl @", DoubleToStr(CurrencyProfit("NZD"),1));}
   }
   //******************************************
   //            All Baskets                  *
   //******************************************
      ThisTimeTarget=BasketTarget;
      if (BasketTotLots >=MaxLotsPerPair   ) ThisTimeTarget=BasketTarget/2;
      if (BasketTotLots>=1.5*MaxLotsPerPair) ThisTimeTarget=BasketTarget/4;
      if (GlobalProfit() >=ThisTimeTarget)
      {
         CloseBasket("EUR"); 
         CloseBasket("GBP");  
         CloseBasket("CAD");  
         CloseBasket("JPY"); 
         CloseBasket("CHF");  
         CloseBasket("USD");  
         CloseBasket("AUD");  
         CloseBasket("NZD");  
         Alert(mode," BasketAll cl @", DoubleToStr(GlobalProfit(),1));
      }

OnScreenComments();

return(0);
}
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//X                              E  N  D      S  T  A  R  T                                               X
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//X                           D  O  P  R  O  G  R  A  M  M                                                X
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

void DoProgramm ()
{ 
   if(digits==3 || digits==5) {vpoint=10*point; Mdig=10;}
   else                       {vpoint=point; Mdig=1;}
   minlot=MarketInfo(Pair,MODE_MINLOT);
   if(minlot==0.01) prec=2;
   if(minlot==0.1)  prec=1;


   //=========================================================================================================
   //=                         Preparation                                                                   =
   //=========================================================================================================
   AdjustParams(Pair);

   LOTHedge  =lastlot         (Pair,magicH);
   TOTHedge  =TotalOpenTrades (Pair,magicH);
   TOTTrade  =TotalOpenTrades (Pair,magicT);

   TOTScale  =TotalOpenTrades (Pair,magicS);
   TYPEScale =lasttype        (Pair,magicS);
   TYPETrade =lasttype        (Pair,magicT);
   PRICETrade=lastprice       (Pair,magicT);
   LOTTrade  =lastlot         (Pair,magicT);
      
   RsiTF0_rsiMax    =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,4,0);//index, shift
   RsiTF0_rsiMin    =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,5,0);

   //EMA_TF2_20       =iMA    (Pair,period2up,  20 ,0,MODE_EMA,PRICE_CLOSE,0);
   //EMA_TF2_200      =iMA    (Pair,period2up,  200,0,MODE_EMA,PRICE_CLOSE,0);
 
   SMA_TF0          =iMA    (Pair,period0,  200,0,MODE_SMA,PRICE_MEDIAN,0);
   SMA_TF1up        =iMA    (Pair,period1up,200,0,MODE_SMA,PRICE_MEDIAN,0);
   rsi_smooth_TF1up =iRSI   (Pair,period1up,rsi_period_smooth,PRICE_CLOSE,0);
   RsiTF0_rsi       =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,0,0);
   RsiTF0_UpB       =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,1,0);
   RsiTF0_LoB       =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,3,0);
   RsiTF0_rsi_OLD   =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,0,1);
   RsiTF0_UpB_OLD   =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,1,1);
   RsiTF0_LoB_OLD   =iCustom(Pair,period0, "Rsi_BB",8,20,2,2,3,1);
   
   rsi       =iRSI   (Pair,period0,5,PRICE_CLOSE,0);
   int trend=Trend(Pair);
   Signal_Strong =Signal2_Strong();
   Signal_Light  =Signal2_Light();

   bool JumpOthersClosing=false; 
   double pr=profitTSH(Pair);
   //=========================================================================================================
   //=             in profit, close by opposite trend                                                        =
   //=========================================================================================================
   if (CloseByOppInProfit==1 && TOTTrade+TOTScale>0 && profitTSH(Pair)>0 )
   {
     if (trend==-1 && TYPETrade==OP_BUY ) {CloseTrades(Pair,ColCloseByOpp);Alert(mode,Pair," ClByOppTrend @", DoubleToStr(pr,1));JumpOthersClosing=true;} 
     if (trend== 1 && TYPETrade==OP_SELL) {CloseTrades(Pair,ColCloseByOpp);Alert(mode,Pair," ClByOppTrend @", DoubleToStr(pr,1));JumpOthersClosing=true;} 
   }

   //=========================================================================================================
   //=             in profit, close by opposite KG                                                           =
   //=========================================================================================================
   if (CloseByOppKG==true && UseKGmode==true && TOTTrade+TOTScale>0 && profitTSH(Pair)>0 && JumpOthersClosing==false)
   {
     if (KgStatus==1  && TYPETrade==OP_BUY ) {CloseTrades(Pair,ColCloseByOpp);Alert(mode,Pair," ClByOppKG @", DoubleToStr(pr,1));JumpOthersClosing=true;} 
     if (KgStatus==-1 && TYPETrade==OP_SELL) {CloseTrades(Pair,ColCloseByOpp);Alert(mode,Pair," ClByOppKG @", DoubleToStr(pr,1));JumpOthersClosing=true;} 
   }

   //=========================================================================================================
   //=                         Closing by Profit                                                             =
   //=========================================================================================================
   BigTarget = CalcTarget(Pair);
   if(TOTTrade+TOTScale>0 && JumpOthersClosing==false)
   {
      Target=BigTarget;    
      if (TOTTrade>=MinTradesForEasyClose )  Target=BigTarget/3;                                            
      if (TOTHedge>0)                        Target=0; 
      
      if (profitTSH(Pair)>=Target)     {CloseTrades(Pair,colclosebyProfitCycle); Alert(mode,Pair," ClByProfit target=", DoubleToStr(Target,1));}
   }
 
   //=========================================================================================================
   //=                         Look time of the last trade                                                   =
   //=========================================================================================================
   if (TOTTrade>0)
   {     cpt=0;
         while(cpt<OrdersTotal())
         {  OrderSelect(cpt,SELECT_BY_POS,MODE_TRADES);  cpt++;
            if(OrderSymbol()==Pair && OrderMagicNumber()==magicT) LastTradeOpenTime=OrderOpenTime();   }
   }
   if (TOTScale>0)
   {     cpt=0;
         while(cpt<OrdersTotal())
         {  OrderSelect(cpt,SELECT_BY_POS,MODE_TRADES);  cpt++;
            if(OrderSymbol()==Pair && OrderMagicNumber()==magicS) LastScaleOpenTime=OrderOpenTime();   }
   }

   //=========================================================================================================
   //=                         Open Trade                                                                    =
   //=========================================================================================================
   //if (NewsExist(Pair) == true && UseEconomicNewsFilter==true && !IsTesting()) OKforOpen=false; else OKforOpen=true;
   OKforOpen=true;
   com=ComT+Pair+"."+DoubleToStr(TOTTrade,0);

   if   (UseKGmode==false)                              
   {
      if (OKforOpen==true && Signal_Strong!=0 &&  TOTTrade+TOTScale==0 )
      {
         if(trend==1   && Signal_Strong<0)  OrderSend(Pair,OP_BUY, StartLot+Increament*MathAbs(Signal_Strong/2),ask,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicT,0,LongTrade);
         if(trend==-1  && Signal_Strong>0)  OrderSend(Pair,OP_SELL,StartLot+Increament*MathAbs(Signal_Strong/2),bid,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicT,0,ShortTrade);
      }
   }//if   (UseKGmode==false)
   else                         
   {
      if (OKforOpen==true &&  TOTTrade+TOTScale==0 )
      {
         KgStatus=LookingKGstatus(Pair);
         if(trend==1   && KgStatus==-1 )  OrderSend(Pair,OP_BUY, StartLot,ask,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicT,0,LongTrade);
         if(trend==-1  && KgStatus==1  )  OrderSend(Pair,OP_SELL,StartLot,bid,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicT,0,ShortTrade);
      }
   }//else

   //=========================================================================================================
   //=                         Scaling In                                                                    =
   //=========================================================================================================
   if (OKforOpen==true && Trend_Scaling()!=0 && TOTTrade>0 && TimeCurrent() - LastTradeOpenTime > 300.0)
   {
      com=ComS+Pair+"."+DoubleToStr(TOTScale,0);
      if (TOTScale==0 && TimeCurrent() - LastTradeOpenTime > 300.0)
         {
          if(Trend_Scaling()>0 && TYPETrade==OP_BUY  && (ask-lastprice(Pair,magicT) >=MinDistanceScal*point)  )  OrderSend(Pair,OP_BUY, StartLotScal,ask,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicS,0,LongTrade);
          if(Trend_Scaling()<0 && TYPETrade==OP_SELL && (lastprice(Pair,magicT)-bid >=MinDistanceScal*point)  )  OrderSend(Pair,OP_SELL,StartLotScal,bid,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicS,0,ShortTrade);
         }
      if (TOTScale>0  && TimeCurrent() - LastScaleOpenTime > 300.0)
         {
          if(Trend_Scaling()>0 && TYPEScale==OP_BUY  && (ask-lastprice(Pair,magicS) >=MinDistanceScal*point)  )  OrderSend(Pair,OP_BUY, StartLotScal,ask,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicS,0,LongTrade);
          if(Trend_Scaling()<0 && TYPEScale==OP_SELL && (lastprice(Pair,magicS)-bid >=MinDistanceScal*point)  )  OrderSend(Pair,OP_SELL,StartLotScal,bid,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicS,0,ShortTrade);
         }
   }

   //=========================================================================================================
   //=                         Martinguale : Opening new trades if new light signal occurs                   =
   //=========================================================================================================
   com=ComT+Pair+"."+DoubleToStr(TOTTrade,0);
   if(OKforOpen==true && TOTTrade>=1 && 
      profitTSH(Pair)<0 && (TOTTrade+TOTScale)<=MaxLotsPerPair &&
     (TimeCurrent() - LastTradeOpenTime) > 300.0)
   
      {  if (IncreaseAutoAtMartin==1)                                            m2Lot=StartLot+TOTTrade*Increament;    else {m2Lot=StartLot;}
         if (IncreaseWithSignalForce==1 &&  (Signal_Light<-1 ||Signal_Light>1))  m2Lot = m2Lot + (MathAbs(Signal_Light)*0.60*Increament);
     
         if(Signal_Light<0 && TYPETrade==OP_BUY && (PRICETrade-ask>=MinDistance*point))
             {
             OrderSend(Pair,OP_BUY ,NormalizeDouble(m2Lot,prec),ask,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicT,0,LongTrade);
             }
         if(Signal_Light>0 && TYPETrade==OP_SELL && (bid-PRICETrade>=MinDistance*point))
             {
             OrderSend(Pair,OP_SELL,NormalizeDouble(m2Lot,prec),bid,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicT,0,ShortTrade);
             }
        
      }//if(TOTTrade>=1 ....

   //=========================================================================================================
   //=                         Hedge                                                             =
   //=========================================================================================================
   com=ComH+Pair+"."+DoubleToStr(TOTHedge,0);

   if (TOTHedge>0)
   {     cpt=0;
         while(cpt<OrdersTotal())
         {  OrderSelect(cpt,SELECT_BY_POS,MODE_TRADES);  cpt++;
            if(OrderSymbol()==Pair && OrderMagicNumber()==magicH) LastHedgeOpenTime=OrderOpenTime();   }
   }

   if (HedgeEnable==1)
   {
         if (profitTSH(Pair)< -(AccountLossForHedging )     &&    (TimeCurrent() -LastHedgeOpenTime) > 900.0)
         {
            TotLongs =TotLongLots (Pair,magicT)+TotLongLots (Pair,magicS)+TotLongLots (Pair,magicH);
            TotShorts=TotShortLots(Pair,magicT)+TotShortLots(Pair,magicS)+TotShortLots(Pair,magicH);
            if (  TotLongs>TotShorts  ) //More longs, do a short
            {  
                   {  
                   hLot=(TotLongLots(Pair,magicT)+TotLongLots(Pair,magicS)-TotShortLots(Pair,magicH));
                   OrderSend(Pair,OP_SELL,NormalizeDouble(hLot,2),bid,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicH,0,ShortHedge);
                   }
            }
            if (  TotLongs<TotShorts  ) //More longs, do a short
            {  
                   {  
                   hLot=(TotShortLots(Pair,magicT)+TotShortLots(Pair,magicS)-TotLongLots(Pair,magicH));
                   OrderSend(Pair,OP_BUY ,NormalizeDouble(hLot,2),ask,MarketInfo(Pair,MODE_SPREAD),0,0,com,magicH,0,LongHedge);
                   }
            }
         }
   }//if (HedgeEnable==1)

   //=========================================================================================================
   //=                                             TrailinStop                                               =
   //=========================================================================================================
   if (TSOnHedge ==1 && TOTHedge>0) TrailingStop(Pair,2*MinDistance, magicH);
   if (TSOnTrades==1 && TOTTrade>0) TrailingStop(Pair,2*MinDistance, magicT);
   if (TSOnScale ==1 && TOTScale>0) TrailingStop(Pair,2*MinDistance, magicS);
   //=========================================================================================================
   //=                         Breakeven                                                                     =
   //=========================================================================================================
   if (BreakEvenOnTrades==1)
   {
      if (TOTTrade>0 && profitTSH(Pair)>0)  CheckBreakEven(Pair,BreakEvenPips, magicT);
   }
   if (BreakEvenOnHedges==1 && TOTHedge>0)  CheckBreakEven(Pair,BreakEvenPips, magicH);
   if (BreakEvenOnScale ==1 && TOTScale>0)  CheckBreakEven(Pair,BreakEvenPips, magicS);

   //=========================================================================================================
   //=                         Larguage                                                                      =
   //=========================================================================================================
   if (larguagrhedgeOnSig==1 && TOTHedge>=1)
   {
       if (TYPETrade==OP_BUY  && Signal_Strong>0) {CloseHedgeTrades(Pair,White); }
       if (TYPETrade==OP_SELL && Signal_Strong<0) {CloseHedgeTrades(Pair,White); }
   }
return(0);
}// end DoProgramm
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//X                         E  N  D     D  O  P  R  O  G  R  A  M  M                                      X
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX



//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//X                        V A R I O U S    S U B R O U T I N E S                                         X
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//+------------------------------------------------------------------+
//| Trend()                                                          |
//+------------------------------------------------------------------+
int Trend(string symbol)
{
   EMA_TF0_20       =iMA (symbol,period0,  20 ,0,MODE_EMA,PRICE_CLOSE,0);
   EMA_TF0_200      =iMA (symbol,period0,  200,0,MODE_EMA,PRICE_CLOSE,0);
   EMA_TF1_20       =iMA (symbol,period1up,  20 ,0,MODE_EMA,PRICE_CLOSE,0);
   EMA_TF1_200      =iMA (symbol,period1up,  200,0,MODE_EMA,PRICE_CLOSE,0);

  if (EMA_TF1_20>EMA_TF1_200) return( 1);
  if (EMA_TF1_20<EMA_TF1_200) return(-1);
return(0);
}

//+------------------------------------------------------------------+
//| Signal2_Strong()                                                 |
//+------------------------------------------------------------------+
int Signal2_Strong()
{  
     if(RsiTF0_rsi_OLD>=RsiTF0_UpB_OLD && RsiTF0_rsi<RsiTF0_UpB && rsi_smooth_TF1up>70)//Overbought 
      {  if (RsiTF0_rsiMax>=92) return( 4);
         if (RsiTF0_rsiMax>=85) return( 3);
         if (RsiTF0_rsiMax>=78) return( 2);
         if (RsiTF0_rsiMax>=70) return( 1);
         return( 1);//Overbought in DownTrend=> SEll
      }
     if(RsiTF0_rsi_OLD<=RsiTF0_LoB_OLD && RsiTF0_rsi>RsiTF0_LoB && rsi_smooth_TF1up<30)//Oversold 
      {  if (RsiTF0_rsiMin<=8 ) return( -4);
         if (RsiTF0_rsiMin<=15) return( -3);
         if (RsiTF0_rsiMin<=22) return( -2);
         if (RsiTF0_rsiMin<=30) return( -1);
         return( -1);//Oversold in UpTrend => BUY
      }
return(0);
}
//+------------------------------------------------------------------+
//| Signal2_Light()                                                  |
//+------------------------------------------------------------------+
int Signal2_Light()
{
  if(RsiTF0_rsi_OLD>=RsiTF0_UpB_OLD && RsiTF0_rsi<RsiTF0_UpB ) //Overbought 
      {  if (RsiTF0_rsiMax>=92) return( 4);
         if (RsiTF0_rsiMax>=85) return( 3);
         if (RsiTF0_rsiMax>=78) return( 2);
         if (RsiTF0_rsiMax>=70) return( 1);
         return( 1);//Overbought in DownTrend=> SEll
      }
  if(RsiTF0_rsi_OLD<=RsiTF0_LoB_OLD && RsiTF0_rsi>RsiTF0_LoB )//Oversold 
      {  if (RsiTF0_rsiMin<=8 ) return( -4);
         if (RsiTF0_rsiMin<=15) return( -3);
         if (RsiTF0_rsiMin<=22) return( -2);
         if (RsiTF0_rsiMin<=30) return( -1);
         return( 1);//Oversold in UpTrend => BUY
      }
  return(0);
}

//+------------------------------------------------------------------+
//| Trend_Scaling()                                                  |
//+------------------------------------------------------------------+
int Trend_Scaling()
{
  if (EMA_TF0_20>EMA_TF0_200) return( 1);
  if (EMA_TF0_20<EMA_TF0_200) return(-1);
return(0);
}

//+------------------------------------------------------------------+
//| profitTSH() All trades  Trade and his Hedge  H2                      |  
//+------------------------------------------------------------------+
double profitTSH(string symbol)
{
   int i=0;double profTrade=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);  i++;
     if(OrderSymbol()==symbol && (OrderMagicNumber()==magicT || OrderMagicNumber()==magicS || OrderMagicNumber()==magicH )) profTrade+=OrderProfit();}//while(i<....  
   return(profTrade);
}

//+------------------------------------------------------------------+
//| CloseTrades()                                                  |
//+------------------------------------------------------------------+
void CloseTrades(string symbol, int col)
{
      for(int i1=OrdersTotal()-1; i1>=0; i1--)
      { OrderSelect(i1,SELECT_BY_POS,MODE_TRADES);
        if(OrderSymbol()==symbol && (OrderMagicNumber()==magicT || OrderMagicNumber()==magicS || OrderMagicNumber()==magicH )) 
         {
         if(OrderType()==OP_BUY)  OrderClose(OrderTicket(),OrderLots(),bid,MarketInfo(symbol,MODE_SPREAD),col);
         if(OrderType()==OP_SELL) OrderClose(OrderTicket(),OrderLots(),ask,MarketInfo(symbol,MODE_SPREAD),col);
         }//if(OrderSymbol()==Symbol().....
      }//for(int......
}

//+------------------------------------------------------------------+
//| CloseHedgeTrades                                                 |
//+------------------------------------------------------------------+
void CloseHedgeTrades(string symbol, int col)
{
      for(int i1=OrdersTotal()-1; i1>=0; i1--)
      { OrderSelect(i1,SELECT_BY_POS,MODE_TRADES);
        if(OrderSymbol()==symbol && OrderMagicNumber()==magicH) 
         {
         if(OrderType()==OP_BUY)  OrderClose(OrderTicket(),OrderLots(),bid,MarketInfo(symbol,MODE_SPREAD),col);
         if(OrderType()==OP_SELL) OrderClose(OrderTicket(),OrderLots(),ask,MarketInfo(symbol,MODE_SPREAD),col);
         }//if(OrderSymbol()==Symbol().....
      }//for(int......
}
//+------------------------------------------------------------------+
//| TotalOpenTrades                                                  |
//+------------------------------------------------------------------+
int TotalOpenTrades(string symbol, int magic)
{  int i=0, TotalOpenTrades=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);i++;
     if(OrderSymbol()==symbol && OrderMagicNumber()==magic ) TotalOpenTrades++;}
   return(TotalOpenTrades);
}
//+------------------------------------------------------------------+
//| lasttype                                                         |
//+------------------------------------------------------------------+
int lasttype(string symbol, int magic)
{  int i=0, type=-1;   
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES); i++;
     if(OrderSymbol()==symbol && OrderMagicNumber()==magic) type=OrderType();}  
   return(type);
}
//+------------------------------------------------------------------+
//| lastprice                                                        |
//+------------------------------------------------------------------+
double lastprice(string symbol, int magic)
{  int i=0;double prc=0; 
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES); i++;
     if(OrderSymbol()==symbol && OrderMagicNumber()==magic ) prc=OrderOpenPrice();}  
   return(prc);
}
//+------------------------------------------------------------------+
//| lastlot                                                          |
//+------------------------------------------------------------------+
double lastlot(string symbol, int magic)
{  int i=0;double lot=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES); i++;
     if(OrderSymbol()==symbol && OrderMagicNumber()==magic) lot=OrderLots();} 
   return(lot);
}
//+------------------------------------------------------------------+
//| TotalLots()                                                      |
//+------------------------------------------------------------------+
double TotLongLots(string symbol, int magic)
{  int i=0; double TotalLots=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);i++;
     if(OrderSymbol()==symbol && OrderMagicNumber()==magic && OrderType()==OP_BUY) TotalLots=TotalLots+OrderLots();}
   return(TotalLots);
}
double TotShortLots(string symbol, int magic)
{  int i=0; double TotalLots=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);i++;
     if(OrderSymbol()==symbol && OrderMagicNumber()==magic && OrderType()==OP_SELL) TotalLots=TotalLots+OrderLots();}
   return(TotalLots);
}
double TotalLots(string symbol, int magic)
{  int i=0; double TotalLots=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);i++;
     if(OrderSymbol()==symbol && OrderMagicNumber()==magic && OrderType()==OP_BUY) TotalLots=TotalLots+OrderLots();}
   return(TotalLots);
}

//+------------------------------------------------------------------+
//| CalculateDailyRange      Average Daily Range                     |
//+------------------------------------------------------------------+
double ADR(string symbol)
{
double    Risk_to_Reward_ratio =  3.0;
double    R1=0,R5=0,R10=0,R20=0,RAvg=0,DynamicRAvg=0;
int       RoomUp=0,RoomDown=0,StopLoss_Long=0,StopLoss_Short=0;
double    SL_Long=0,SL_Short=0;
double    low0=0,high0=0;
   int i=0;
   R1 =  (iHigh(symbol,PERIOD_D1,1)-iLow(symbol,PERIOD_D1,1))/vpoint;
   for(i=1;i<=5;i++)
      R5    =    R5  +  (iHigh(symbol,PERIOD_D1,i)-iLow(symbol,PERIOD_D1,i))/vpoint;
   for(i=1;i<=10;i++)
      R10   =    R10 +  (iHigh(symbol,PERIOD_D1,i)-iLow(symbol,PERIOD_D1,i))/vpoint;
   for(i=1;i<=20;i++)
      R20   =    R20 +  (iHigh(symbol,PERIOD_D1,i)-iLow(symbol,PERIOD_D1,i))/vpoint;
   R5    = R5/5;
   R10   = R10/10;
   R20   = R20/20;
   RAvg  =  (R1+R5+R10+R20)/4;    //donne le résultat en pips 4 digits

   low0     =  iLow(symbol,PERIOD_D1,0);
   high0    =  iHigh(symbol,PERIOD_D1,0);
   RoomUp   =  RAvg - (bid - low0)/vpoint;
   RoomDown =  RAvg - (high0 - bid)/vpoint;
   StopLoss_Long  =  RoomUp/Risk_to_Reward_ratio;
   SL_Long        =  bid - StopLoss_Long*vpoint;
   StopLoss_Short =  RoomDown/Risk_to_Reward_ratio;
   SL_Short       =  bid + StopLoss_Short*vpoint;
   if (R1>RAvg) DynamicRAvg=R1; else DynamicRAvg=RAvg;
   if (R5>R1 && R1>RAvg && R5>RAvg) DynamicRAvg=R5; 
   if (StringSubstr(symbol, 3, 3) == "JPY") { DynamicRAvg=DynamicRAvg/100; }

return (DynamicRAvg);
}
//+------------------------------------------------------------------+
//| TickValueinEuros                                                 |
//+------------------------------------------------------------------+

double TickValueinEuros(string symbol)
{
   double TickValue = MarketInfo(symbol, MODE_TICKVALUE);
   if (IsTesting()) EurValue=EurValueForBT; else EurValue=MarketInfo("EURUSD",MODE_BID);
   double TickValueinEuros=TickValue/EurValue;
return (TickValueinEuros);
}

//+------------------------------------------------------------------+
//| AdjustParams                                                     |
//+------------------------------------------------------------------+
void AdjustParams(string symbol)
{
   ADR(symbol);
   //InitialMinDistance      =InitialMinDistance  *coef;
   MinDistance       =ADR(symbol)/4;
   MinDistanceScal       =ADR(symbol)/10;
   if (MinDistance<InitialMinDistance) MinDistance=InitialMinDistance;
   if (MinDistanceScal<InitialMinDistanceScal) MinDistanceScal=InitialMinDistanceScal;

   BreakEvenPips  =  InitialBreakEvenPips;


   TrailingStop=BreakEvenPips; 
}

//+------------------------------------------------------------------+
//| TrailingStop                                                     |
//+------------------------------------------------------------------+
void TrailingStop(string symbol,int trailing_stop,int magic)
{
   double ts;
   for (int i = OrdersTotal()-1; i >= 0; i --) 
   {
      OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if (OrderSymbol() ==symbol && OrderMagicNumber()==magic)
      {
         if (OrderType() == OP_BUY)
         {
            ts = bid-(point*trailing_stop);
            if (OrderStopLoss()+jump*point<ts && (bid-OrderOpenPrice())>=(point*trailing_stop))
         OrderModify(OrderTicket(),OrderOpenPrice(),ts,OrderTakeProfit(),0,White);
         }
         if (OrderType() == OP_SELL)
         {
            ts = ask+(point*trailing_stop);
            if (OrderStopLoss()!=0)
               {if (OrderStopLoss()-jump*point>ts && (OrderOpenPrice()-ask)>=(point*trailing_stop))
                  OrderModify(OrderTicket(),OrderOpenPrice(),ts,OrderTakeProfit(),0,White);
               }
            else
               {if ((OrderOpenPrice()-ask)>=(point*trailing_stop))
                  OrderModify(OrderTicket(),OrderOpenPrice(),ts,OrderTakeProfit(),0,White);
               }
         } 
      }//if (OrderSymbol()           
   }//for (int i
}
//+------------------------------------------------------------------+
//| CheckBreakEven()                                                 |
//+------------------------------------------------------------------+
void CheckBreakEven(string symbol,int BEP, int magic)
{
   int RetError; bool BoolError; double newstoploss = 0;
   for (int counter = 0; counter < OrdersTotal(); counter++) 
   {  OrderSelect(counter, SELECT_BY_POS, MODE_TRADES);
      if (OrderType() == OP_BUY && OrderMagicNumber() == magic && OrderSymbol() == symbol) 
      {        
      if (BEP > 0 && OrderStopLoss() < OrderOpenPrice() )
         if ( bid >= OrderOpenPrice() + BEP*point )
         {     OrderModify(OrderTicket(), OrderOpenPrice(), OrderOpenPrice(), OrderTakeProfit(), 0, White);    BoolError = TRUE;   }
      }//if (OrderType() == OP_BUY...
      
      if (OrderType() == OP_SELL && OrderMagicNumber() == magic  && OrderSymbol() == symbol) 
      {
         if (BEP > 0 && OrderStopLoss() > OrderOpenPrice())
         if ( ask <= OrderOpenPrice() - BEP*point )
         {     OrderModify(OrderTicket(), OrderOpenPrice(), OrderOpenPrice(), OrderTakeProfit(), 0, White);    BoolError = TRUE;  }
      }//if (OrderType() == OP_SELL....  

   }//for (int counter ....
}
//+------------------------------------------------------------------+
//| CalcTarget                                                       |
//+------------------------------------------------------------------+
double CalcTarget(string symbol)
{
double target;
if (UseKGmodeJPYRollercoster==false)
   target=   coefP*OptimTarget*3*StartLot*ADR(symbol)*TickValueinEuros(symbol)
              +(TotLongLots(symbol,magicT)+TotLongLots(symbol,magicS)+TotShortLots(symbol,magicT)+TotShortLots(symbol,magicS))/3;
else
   target=   coefP*OptimTarget*4*StartLot*ADR(symbol)*TickValueinEuros(symbol)*5;
return (target);
}
//+------------------------------------------------------------------+
//| OnScreenComments                                                 |StartLot
//+------------------------------------------------------------------+

void OnScreenComments()
{
   string esp="   ";
   ScreenMessage = "";
   int cc;
   ScreenMessage = StringConcatenate(ScreenMessage, "EAMode ", DoubleToStr(EAMode,0)," (",mode,")"," Nb pairs running: ",DoubleToStr(NoOfPairs,0), NL);
   if (UseKGmodeJPYRollercoster==true) ScreenMessage = StringConcatenate(ScreenMessage, "Mode JPY RollerCoaster", NL);
   ScreenMessage = StringConcatenate(ScreenMessage,  "UseKGmode : ", UseKGmode, "  EAMagic= : ",DoubleToStr(EAMagic,0), "  StartLot= : ",DoubleToStr(StartLot,2),NL);
   ScreenMessage = StringConcatenate(ScreenMessage,  "UseEconomicNewsFilter : ", UseEconomicNewsFilter, NL);
   ScreenMessage = StringConcatenate(ScreenMessage, "BasketTarget : ", DoubleToStr(BasketTarget,1), "  ThisTimeTarget : ", DoubleToStr(ThisTimeTarget,1), "  GlobalProfit : ", DoubleToStr(GlobalProfit(),1),NL);
   ScreenMessage = StringConcatenate(ScreenMessage, "CurrencyTarget : ", DoubleToStr(CurrencyTarget,1), NL);
   ReadKGValues(); 
   ScreenMessage = StringConcatenate(ScreenMessage,  "         ", " Jpy   ", " Usd   "," Gbp   "," Eur   "," Chf  "," Aud   "," Nzd   "," Cad   ",NL);
   ScreenMessage = StringConcatenate(ScreenMessage,  "KG:     ",  DoubleToStr(JpyKgRS,1) , esp, 
                                                                  DoubleToStr(UsdKgRS,1) , esp, 
                                                                  DoubleToStr(GbpKgRS,1) , esp, 
                                                                  DoubleToStr(EurKgRS,1) , esp, 
                                                                  DoubleToStr(ChfKgRS,1) , esp, 
                                                                  DoubleToStr(AudKgRS,1) , esp, 
                                                                  DoubleToStr(NzdKgRS,1) , esp, 
                                                                  DoubleToStr(CadKgRS,1) , esp, 
                                                               NL);
   ScreenMessage = StringConcatenate(ScreenMessage,  "Prof.   ",  DoubleToStr(CurrencyProfit("JPY"),0) , esp, 
                                                                  DoubleToStr(CurrencyProfit("USD"),0) , esp, 
                                                                  DoubleToStr(CurrencyProfit("GBP"),0) , esp, 
                                                                  DoubleToStr(CurrencyProfit("EUR"),0) , esp, 
                                                                  DoubleToStr(CurrencyProfit("CHF"),0) , esp, 
                                                                  DoubleToStr(CurrencyProfit("AUD"),0) , esp, 
                                                                  DoubleToStr(CurrencyProfit("NZD"),0) , esp, 
                                                                  DoubleToStr(CurrencyProfit("CAD"),0) , esp, 
                                                               NL);

      //ScreenMessage = StringConcatenate(ScreenMessage, NL);
      for (cc = 0; cc < NoOfPairs; cc++)
      {
        int trend=Trend(TradePair[cc]);
        double RsiTF0_rsi       =iCustom(TradePair[cc],period0, "Rsi_BB",8,20,2,2,0,0);

         string txtTrend="Flat";
         if (trend==1 )  txtTrend="Long ";
         if (trend==-1)  txtTrend="Short";
         string txtKGstat="--";
         if (LookingKGstatus(TradePair[cc])==1 )txtKGstat="OB";
         if (LookingKGstatus(TradePair[cc])==-1)txtKGstat="OS";
         /*if (TradeDirection != none) */ ScreenMessage = StringConcatenate(ScreenMessage, ".", TradePair[cc], "- Trend=", txtTrend, " KG=", txtKGstat," -Rsi=", DoubleToStr(RsiTF0_rsi,1),
                         " | T/S/H= ", DoubleToStr(TotalOpenTrades(TradePair[cc],magicT),0), "/",DoubleToStr(TotalOpenTrades(TradePair[cc],magicS),0), "/",DoubleToStr(TotalOpenTrades(TradePair[cc],magicH),0),
                         " BigTarget=", DoubleToStr(CalcTarget(TradePair[cc]),1),".€"," Profit=", DoubleToStr(profitTSH(TradePair[cc]),0),
                         " ADR=", DoubleToStr(ADR(TradePair[cc]),1), " BE=",DoubleToStr(BreakEvenPips,1) , " TV= ", DoubleToStr(TickValueinEuros(TradePair[cc]), 4), "-", NL );
      }//for (cc = 0; cc < NoOfPairs; cc==)
   
   Comment(ScreenMessage);

}
void   ReadKGValues()
{   
   JpyKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",1,0);
   UsdKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",0,0);
   GbpKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",4,0);
   EurKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",6,0);
   ChfKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",2,0);
   AudKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",5,0);
   NzdKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",7,0);
   CadKgRS = iCustom(NULL,period0, "KG RS GROUP V1.1",3,0);
}
int   LookingKGstatus(string symbol)
{   
   ReadKGValues(); 
   int ret=0;
   if (StringSubstr(symbol, 0, 6) == "AUDCAD")
      {if (AudKgRS>UpTrig && CadKgRS<LoTrig) ret=1 ;//OB
       if (AudKgRS<LoTrig && CadKgRS>UpTrig) ret=-1;//OS
      }
   if (StringSubstr(symbol, 0, 6) == "AUDCHF") 
      {if (AudKgRS>UpTrig && ChfKgRS<LoTrig) ret=1 ;
       if (AudKgRS<LoTrig && ChfKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "AUDJPY")
      {if (AudKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (AudKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "AUDNZD") 
      {if (AudKgRS>UpTrig && NzdKgRS<LoTrig) ret=1 ;
       if (AudKgRS<LoTrig && NzdKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "AUDUSD") 
      {if (AudKgRS>UpTrig && UsdKgRS<LoTrig) ret=1 ;
       if (AudKgRS<LoTrig && UsdKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "CADCHF") 
      {if (CadKgRS>UpTrig && ChfKgRS<LoTrig) ret=1 ;
       if (CadKgRS<LoTrig && ChfKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "CADJPY") 
      {if (CadKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (CadKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "CHFJPY") 
      {if (ChfKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (ChfKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "EURAUD") 
      {if (EurKgRS>UpTrig && AudKgRS<LoTrig) ret=1 ;
       if (EurKgRS<LoTrig && AudKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "EURCAD") 
      {if (EurKgRS>UpTrig && CadKgRS<LoTrig) ret=1 ;
       if (EurKgRS<LoTrig && CadKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "EURCHF") 
      {if (EurKgRS>UpTrig && ChfKgRS<LoTrig) ret=1 ;
       if (EurKgRS<LoTrig && ChfKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "EURGBP") 
      {if (EurKgRS>UpTrig && GbpKgRS<LoTrig) ret=1 ;
       if (EurKgRS<LoTrig && GbpKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "EURJPY") 
      {if (EurKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (EurKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "EURNZD") 
      {if (EurKgRS>UpTrig && NzdKgRS<LoTrig) ret=1 ;
       if (EurKgRS<LoTrig && NzdKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "EURUSD") 
      {if (EurKgRS>UpTrig && UsdKgRS<LoTrig) ret=1 ;
       if (EurKgRS<LoTrig && UsdKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "GBPAUD") 
      {if (GbpKgRS>UpTrig && AudKgRS<LoTrig) ret=1 ;
       if (GbpKgRS<LoTrig && AudKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "GBPCAD") 
      {if (GbpKgRS>UpTrig && CadKgRS<LoTrig) ret=1 ;
       if (GbpKgRS<LoTrig && CadKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "GBPCHF") 
      {if (GbpKgRS>UpTrig && ChfKgRS<LoTrig) ret=1 ;
       if (GbpKgRS<LoTrig && ChfKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "GBPJPY") 
      {if (GbpKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (GbpKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "GBPNZD") 
      {if (GbpKgRS>UpTrig && NzdKgRS<LoTrig) ret=1 ;
       if (GbpKgRS<LoTrig && NzdKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "GBPUSD") 
      {if (GbpKgRS>UpTrig && UsdKgRS<LoTrig) ret=1 ;
       if (GbpKgRS<LoTrig && UsdKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "NZDCAD") 
      {if (NzdKgRS>UpTrig && CadKgRS<LoTrig) ret=1 ;
       if (NzdKgRS<LoTrig && CadKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "NZDCHF") 
      {if (NzdKgRS>UpTrig && ChfKgRS<LoTrig) ret=1 ;
       if (NzdKgRS<LoTrig && ChfKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "NZDJPY") 
      {if (NzdKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (NzdKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "NZDUSD") 
      {if (NzdKgRS>UpTrig && UsdKgRS<LoTrig) ret=1 ;
       if (NzdKgRS<LoTrig && UsdKgRS>UpTrig) ret=-1;
      }
/*   if (StringSubstr(symbol, 0, 6) == "SGDJPY") 
      {if (SgdKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (SgdKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }*/
   if (StringSubstr(symbol, 0, 6) == "USDCHF") 
      {if (UsdKgRS>UpTrig && ChfKgRS<LoTrig) ret=1 ;
       if (UsdKgRS<LoTrig && ChfKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "USDCAD") 
      {if (UsdKgRS>UpTrig && CadKgRS<LoTrig) ret=1 ;
       if (UsdKgRS<LoTrig && CadKgRS>UpTrig) ret=-1;
      }
/*   if (StringSubstr(symbol, 0, 6) == "USDDKK") 
      {if (UsdKgRS>UpTrig && DkkKgRS<LoTrig) ret=1 ;
       if (UsdKgRS<LoTrig && DkkKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "USDDKK") 
      {if (UsdKgRS>UpTrig && HkdKgRS<LoTrig) ret=1 ;
       if (UsdKgRS<LoTrig && HkdKgRS>UpTrig) ret=-1;
      }*/
   if (StringSubstr(symbol, 0, 6) == "USDJPY") 
      {if (UsdKgRS>UpTrig && JpyKgRS<LoTrig) ret=1 ;
       if (UsdKgRS<LoTrig && JpyKgRS>UpTrig) ret=-1;
      }
/*   if (StringSubstr(symbol, 0, 6) == "USDNOK") 
      {if (UsdKgRS>UpTrig && NokKgRS<LoTrig) ret=1 ;
       if (UsdKgRS<LoTrig && NokKgRS>UpTrig) ret=-1;
      }
   if (StringSubstr(symbol, 0, 6) == "USDSEK") 
      {if (UsdKgRS>UpTrig && SekKgRS<LoTrig) ret=1 ;
       if (UsdKgRS<LoTrig && SekKgRS>UpTrig) ret=-1; // SGDJPY USDDKK USDHKD USDNOK USDSEK XAGUSD XAUUSD
      }*/
return(ret);
}
/*
----------------------
Latest Revision History

0 >> 100  : first attemps
100 >> 200  : 2 cycles
200 >> 300  : 3 cycles

300    : various try
301    : various try
302    : removed 1 tf rsi
303    : bug correction
304    : various try
305    : hedge mod
306    : martinguale mod
307    : various try
308    : various try
309    : various try
310    : various try
310b   : hedge use TOTHx
310c   : big signal increase lot
310d   : add signal on martinguale
310e   : Modif opentrades with adjacent cycle
311    : Wash code
312    : Mofify Signal_Light (add trend verif)
312b   : Use RSI(2)
313    : Bug Correction, come back to hedge OLDious
313b   : Bug Correction
313c   : Add Larguage Hedge
313d   : Add DynamicRAvg
313e   : Correct DynamicRAvg
313f   : Different modes for larguage Hedge
314    : Speed UP code execution (if IsnewBar) 
314b   : remove methods for signal looks like Ilan only Buy, SL ,TP
314c   : various tests
314d   : various tests
314e   : various tests
314e1  : various tests
314e2  : various tests
314e3  : various tests
314e31 : various tests
314e32 : various tests
314e33 : various tests
314e34 : various tests
314e35 : various tests
314e36 : various tests
314e37 : various tests
314e38 : various tests
320    : Reload 313f - new trailing Stop, removed extra tBug Correction, come back to hedge OLDious
311    : Wash code : general indics calculation
322    : 2 different period rsi : smooth
323    : various mods
324    : various mods
325    : not bad with TS cycle=0, Ts Hedge=1
325W   : OK AUDUSD, EURJPY, GBPJPY, NZDUSD   *** prob on EURUSD
326    : Pyramiding *** prob
326+   : Ts on single trade cycle
327    : Hedge on Maxlevel Only
328    : Do not take care OLD
329    : Pyramiding
330    : Pyramiding improvement
331    : TS on Pyramiding 
332    : Pyramiding improvement
333    : Differents levels for signal
333c   : totallots corrected
333d   : signals with Rsi
334    : try
335    : try
336    : try
340    : try
350    : try
351    : try
351b   : try
351c   : try
351d   : Good version
         Faster code using mid bands
         Trailing stop with jump is working
         Differents levels for Signals
351e   : if NewBar for some indics         
351g   : Arrange code for better read; 
         ClosingByOppMACDSingleTrade if TOTCx==1        
360    : Up version Number
361    : bug fix
362    : Removed C0 Cycle, back to 2 cycles
363    : Add SIG_strong for ClosingByOpp
         Add CloseByOppSig
364    : switch JustCloseByOpp
400    : Basket_0364_insp310d 
       : many ideas back to 310d : many hedges, BE, signal
450    : rethinking
451    : larg hedge id inv sig
452    : hedge in account loss
500    : Basket_0481_period.mq4 + multipairs
501    : Corrected
502    : add SingleSymbol for backtesting
         add KG filter
         add news filter
*/

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+   Basket                                                         +
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

int BasketLOT(string cur)
{  int i=0, TotalLots=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);i++;
     if( (StringSubstr(OrderSymbol(), 0, 3)==cur || StringSubstr(OrderSymbol(), 3, 3)==cur )   && (OrderMagicNumber()==magicT ||OrderMagicNumber()==magicS || OrderMagicNumber()==magicH) )   TotalLots+=OrderLots();}
   return(TotalLots);
}
double CurrencyProfit(string cur)
{  int i=0;double profC12=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);  i++;
     if( (StringSubstr(OrderSymbol(), 0, 3)==cur || StringSubstr(OrderSymbol(), 3, 3)==cur )   && (OrderMagicNumber()==magicT ||OrderMagicNumber()==magicS || OrderMagicNumber()==magicH)   ) profC12+=OrderProfit(); }//while(i<....  
   return(profC12);
}
double GlobalProfit()
{  int i=0;double profC12=0;
   while(i<OrdersTotal())
   { OrderSelect(i,SELECT_BY_POS,MODE_TRADES);  i++;
     if( OrderMagicNumber()==magicT ||OrderMagicNumber()==magicS || OrderMagicNumber()==magicH ) profC12+=OrderProfit(); }//while(i<....  
   return(profC12);
}

void CloseBasket(string cur)
{     for(int i1=OrdersTotal()-1; i1>=0; i1--)
      { OrderSelect(i1,SELECT_BY_POS,MODE_TRADES);
        if( (StringSubstr(OrderSymbol(), 0, 3)==cur || StringSubstr(OrderSymbol(), 3, 3)==cur ) && (OrderMagicNumber()==magicT ||OrderMagicNumber()==magicS || OrderMagicNumber()==magicH)   ) 
         {
         if(OrderType()==OP_BUY)  OrderClose(OrderTicket(),OrderLots(),bid,MarketInfo(Symbol(),MODE_SPREAD),ColCurrencyBasket);
         if(OrderType()==OP_SELL) OrderClose(OrderTicket(),OrderLots(),ask,MarketInfo(Symbol(),MODE_SPREAD),ColCurrencyBasket);
         }//if(OrderSymbol()==Symbol().....
      }//for(int......
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+   Steve and Scoobs routines                                      +
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void CleanUpInputString()
{
   // Does any tidying up of the user inputs
   
   //Remove unwanted spaces
   InputString = StringTrimLeft(InputString);
   InputString = StringTrimRight(InputString);

   //Add final comma if ommitted by user
   if (StringSubstr(InputString, StringLen(InputString)-1) != ",") 
      InputString = StringConcatenate(InputString,",");
      
   
}//void CleanUpInputString

void CalculatePairsPassed()
{
   // Calculates the numbers of paramaters passed in MagicNumber and TradeComment.
   
   int Index = 0;//For searching NoTradePairs
   int LastIndex;//Points the the most recent Index
   
   while(Index > -1)
      {
         Index = StringFind(InputString, ",",LastIndex);
         if (Index > -1)
         {
            NoOfPairs ++;
            LastIndex = Index+1;            
         }//if (Index > -1)
      }//while(int cc > -1)
   
   
   
}//End void CalculatePairsPassed()
/*
bool NewsExist(string symbol)
{
  
    bool News = false;
    
    int minutesSincePrevEvent =
      iCustom(NULL, 0, "Economic News", symbol, true, false, false, true, true, 1, 0);

    int minutesUntilNextEvent =
      iCustom(NULL, 0, "Economic News", symbol, true, false, false, true, true, 1, 1);

    if((minutesUntilNextEvent <= 60) || 
       (minutesSincePrevEvent <= 15))
      {
        News = true;
      }
      
    return(News);

}
*/
/*bool NewsExist(string symbol)
  {
  
    string NewsPairs[] = {"EURUSD","USDJPY","GBPUSD","USDCHF"};
    bool   News        = false;
    
    string Suffix = StringSubstr(Symbol(),6,StringLen(Symbol())-6);

    for(int d = 0; d < ArraySize(NewsPairs); d++)
      {
        NewsPairs[d] = NewsPairs[d] + Suffix;
      }
    
    if(StringFind(NewsPairs,symbol,0) < 0)
      {
        ArrayResize(NewsPairs,4);
        NewsPairs[4] = symbol;
      }
      
    for(int e = 0; e < ArraySize(NewsPairs); e++)
      {
        int MinutesSincePrevEvent =
          iCustom(NULL, 0, "Economic News", NewsPairs[e], true, false, false, true, true, 1, 0);

        int MinutesUntilNextEvent =
          iCustom(NULL, 0, "Economic News", NewsPairs[e], true, false, false, true, true, 1, 1);

        if((MinutesUntilNextEvent <= 60) || 
           (MinutesSincePrevEvent <= 15))
          {
            News = true;
          }
      }
      
    return(News);

  }
  */