#property copyright "Rafael Morgado Silva"
#property link      ""
#property version   "1.00"

#include <Math\Stat\Math.mqh>
#include <Trade\Trade.mqh>
#include "Include\defs.mqh"//definições gerais, parâmetros gerais
#include "Include\locks.mqh"//travas
#include "Include\manage.mqh"//gerenciaento de ordens/posições
#include "Include\stops.mqh"//Stop loss e take profit
#include "Include\strategy.mqh"//estratégias
#include "Include\filters.mqh"//filtros
struct MyData//Callback com a estrutura de dados do robô
{
   CLock* Lock;
   PLock* PosLock;
   ALock* AssetLock;
   Signal* StrategyB1;
   Signal* StrategyB2;
   Signal* StrategyS1;
   Signal* StrategyS2;
   Filters* Liquidity;
   Filters* PriceMin;
   OrderData* PosData;
   void operator=(const MyData &r)
   {
      Lock=r.Lock;
      PosLock=r.PosLock;
      AssetLock=r.AssetLock;
      StrategyB1=r.StrategyB1;
      StrategyB2=r.StrategyB2;
      StrategyS1=r.StrategyS1;
      StrategyS2=r.StrategyS2;
      Liquidity=r.Liquidity;
      PriceMin=r.PriceMin;
      PosData=r.PosData;
   }
};
#include "Include\ranking.mqh"//tabela, ordenamento, ranking
#include "Include\money.mqh"//gerenciamento de saldo, margem, etc
//#include <report.mqh>//para gerar o relatório personalizado em pdf
#include "Include\data.mqh"
#include "Include\report.mqh"
//#include <Graphics\Graphic.mqh>

input string LineE11="-----------------------Parâmetros Estratégia 1 ------------------";
input MODEL_TYPES E1ModelType=Tendencia;//Tipo de modelo
input ENUM_TIMEFRAMES E1TimeFrameB=PERIOD_M15;//Timeframe ATR compra
input int E1PAtrB=21;//Período do ATR compra
input ENUM_TIMEFRAMES E1TimeFrameS=PERIOD_M15;//Timeframe ATR venda
input int E1PAtrS=21;//Período do ATR venda
input REF_TYPES E1Type=Ref_price_maxmin;//Tipo de estratégia
input REF_PRICES_TYPES E1Price=Ref_pt_maxmin;//Tipo de preço
input int E1Periodo=7;//Número de barras no sinal
input ENUM_TIMEFRAMES E1RefTimeFrame=PERIOD_M5;//Timeframe da referência
input double E1AtrFrac=0.0;//Fração do Atr de deslocamento
input bool E1ConfCandle=false;//Usar candle de confirmação do rompimento
input string python_fname="";//Nome do script python
input bool UsePythonTicker=true;//Usar o ticker do script python
input bool UsePythonVolume=true;//Usar o volume do script python
input string LineE12="----------------------------------------------------------";

input string E21="-----------------------Parâmetros Estratégia 2 ------------------";
input MODEL_TYPES E2ModelType=Tendencia;//Tipo de modelo
input ENUM_TIMEFRAMES E2TimeFrameB=PERIOD_M15;//Timeframe ATR compra
input int E2PAtrB=21;//Período do ATR compra
input ENUM_TIMEFRAMES E2TimeFrameS=PERIOD_M15;//Timeframe ATR venda
input int E2PAtrS=21;//Período do ATR venda
input REF_TYPES E2Type=Ref_price_maxmin;//Tipo de estratégia
input REF_PRICES_TYPES E2Price=Ref_pt_maxmin;//Tipo de preço
input int E2Periodo=7;//Número de barras no sinal
input ENUM_TIMEFRAMES E2RefTimeFrame=PERIOD_M5;//Timeframe da referência
input double E2AtrFrac=0.0;//Fração do Atr de deslocamento
input bool E2ConfCandle=false;//Usar candle de confirmação do rompimento
input string E22="----------------------------------------------------------";

/*input string Shadow1="-----------------------Parâmetros shadow -----------------";
input bool AtrVar_shadow=false;//Usar janela variável com ATR
input bool SignalOrig_shadow=true;//Sinal original - lag preço/código - lag ssb
input string Shadow2="----------------------------------------------------------";

input string Elefante1="-----------------------Parâmetros Elefante -----------------";
input bool RRFilter_elefante=true;//Usar filtro de Retorno/Risco
input double RRFrac_elefante=0.33;//Fração RR
input bool SSBFilter_elefante=true;//Usar filtro SSB
input bool ConfCandle_elefante=true;//Usar candle de confirmação do rompimento

input bool SlOrig_elefante=false;//SL original - extensão acima(abaixo) pivô/ponto médio do elefante
input bool TpOrig_elefante=false;//TP original - extensão baixo(acima) pivô/extensão acima(abaixo) elefante

input bool PivotCandle_elefante=false;//Usar candle de pivot - rompimento do pivô/elefante
input bool BodyElefant_elefante=true;//Usar só o corpo do candle elefante
input bool BodyPivot_elefante=false;//Usar só o corpo do candle pivô
input string Elefante2="-------------------------------------------------------------";*/

input string Ft11="----------------Parâmetros Filtro 1 -----------------------";
input bool UseFilter1=false;//Habilitar filtro
input FILTER_TYPES MyFilter1=FTLiq;//Tipo de filtro
input double LiqFrac1=0.95;//Corte filtro de liquidez
input ENUM_TIMEFRAMES FTimeFrame1=PERIOD_D1;//Timeframe do filtro
input int FPeriod1=30;//Período do filtro
input string FSymbol1="IBOV";//Ativo referência para o filtro
input string Ft21="------------------------------------------------------------";

input string Ft12="----------------Parâmetros Filtro 2-------------------------";
input bool UseFilter2=false;//Habilitar filtro
input FILTER_TYPES MyFilter2=FTPre;//Tipo de filtro
input double PreMin2=4;//Preço mínimo
input string Ft22="------------------------------------------------------------";

input string T12="-----------------------Parâmetros da Tabela-------";
//input string TableFile="mlcx-09-12.txt";//Arquivo com os tickers
input Periodicity TablePeriodicity=Mes;//Periodicidade da tabela
input ENUM_TIMEFRAMES TableTimeframe=PERIOD_D1;//Timeframe da tabela
input int TablePeriod=120;//Janela da tabela
input ENUM_TIMEFRAMES TableAtrTimeframe=PERIOD_D1;//Timeframe do atr
input int TableAtrPeriod=21;//Janela do atr
input RankTypes MyRank=RTRent_atr;//Tipo de ordenamento
input RankSelectTypes MySelectionType=RSTAll;//Tipo de seleção
input int RSTFixedAssets=20;//Número de ativos (seleção fixa)
input bool UseRenorm=true;//Renormalizar a tabela
input bool UseTableLiqFilter=true;//Habilitar filtro de liquidez na tabela
//input double liqfrac=0.95;//Corte filtro de liquidez
//input int liqper=30;//Janela do filtro liquidez
//input ENUM_TIMEFRAMES liqtime=PERIOD_M5;//Timeframe do filtro de liquidez
//input string liqrefsymb="IBOV";//Ativo referência para o filtro de liquidez
input bool UseTablePreFilter=true;//Habilitar filtro de preço na tabela
input double premin=4;//Preço mínimo
input bool UseTableLowVolFilter=true;//Habilitar filtro somente positivos na tabela
input double Alavancagem=5;//Alavancagem
input bool UseRebal=false;//Usar algoritmo de rebalanço
input bool ChangeCapital=false;//Redimensionar a carteira atual, mudando o capital
input int THour=9;//Horário de cálculo da carteira
input int TMin=0;//Minuto de cálculo da carteira
input bool EnableMonteCarlo=false;//Habilitar Monte Carlo com a lista de ativos
input int NativosMonteCarlo=50;//Número de ativos por teste
input int SeedMonteCarlo=0;//Semente aleatória do teste
input string T22="---------------------------------------------------";
input string T23="---------------Neutralização-----------------------";
input bool UseNeutralization=false;//Habilita neutralização da carteira
input string NeutralAsset1="WDO$D";//Ativo neutralizador 1 (comprado)
input string NeutralAsset2="WIN$D";//Ativo neutralizador 2 (vendido)
input Neutralization_TYPES NeutralMethod=NTRisco;//Tipo de neutralização
input string T24="---------------------------------------------------";

input string M12="---------------Gerenciamento de Saldo--------------";
input bool MGMTMargin=true;//Usar limitação de margem
input ENUM_MONEY_MGMT MGMTType=MMTAccount;//Tipo de gerenciamento
input double mycapital=100000;//Capital (fixo)
input double mymargin=200000;//Margem (fixo)
input double mymarginfrac=2;//Margem em % do saldo (Saldo)
input string M22="---------------------------------------------------";
input string N12="---------------Telegram--------------";
input bool UseTelegram;//Habilitar bot no Telegram
input bool EqtyPlot=true;//Gráfico de saldo(T) ou investido(F)
input string N22="---------------------------------------------------";

CTrade Trade;
Table Assets;
MoneyMgmt Money;
MyTimer ThisTimer;
string MyName;
DataAquisition Metadata,Reportdata;
BotTelegram ThisBot;
string TelegramBuffer;
//bool TelegramSendLogs=false;
//long TelegramLogsIds[];
//Position MyPositions;

void OnTimer()
{
   if ((!MQLInfoInteger(MQL_TESTER))&&(!MQLInfoInteger(MQL_OPTIMIZATION)))//online
   {
      double profit=0;
      double f_profit=0;
      for (int i=0;i<ArraySize(Assets.data);i++)
      {
         string ticker=Assets.data[i].ticker;
         profit+=calc_profit(ticker,DEAL_TYPE_SELL);
         profit+=calc_profit(ticker,DEAL_TYPE_BUY);
         f_profit+=float_profit(ticker,POSITION_TYPE_BUY);
         f_profit+=float_profit(ticker,POSITION_TYPE_SELL);
         Assets.data[i].mydata.Lock.CheckLock(ticker,LockExp);
         Assets.data[i].mydata.PosLock.CheckLock(ticker,LockExp);
      }
      Comment(TimeToString(TimeLocal(),TIME_DATE|TIME_SECONDS)+"\n"+
                           "Lucro realizado: "+DoubleToString(profit,2)+" "+DoubleToString(100.0*profit/Money.Balance(),2)+"%\n"
                           "Lucro flutuante: "+DoubleToString(f_profit,2)+" "+DoubleToString(100.0*f_profit/Money.Balance(),2)+"%\n");            
   
/*      MqlDateTime today;//Relatórios diários
      TimeLocal(today);
      if ((today.hour>=18)&&(today.min>=1)&&(today.day_of_week!=SATURDAY)&&(today.day_of_week!=SUNDAY))
      {
         if (FileIsExist(MyName+"-dailyreport.csv"))
         {
            MqlDateTime fdata;
            TimeToStruct((datetime)FileGetInteger(MyName+"-dailyreport.csv",FILE_MODIFY_DATE),fdata);
            if ((fdata.day!=today.day)||((fdata.day==today.day)&&(fdata.hour==18)&&(fdata.min<1))||((fdata.day==today.day)&&(fdata.hour<18)))
            {
               Metadata.FileToFile(MyName);//lê MyName+DataFname, salva MyName+"-dailyreport.csv"
               ShellOpenFile(MyName+"-dailyreport.bat");//chama gnuplot MyName+"-daylyreport.gp"
               if (UseTelegram)
               {
                  Sleep(10*1000);
                  ThisBot.SendResult();
               }
            }
         }
         else
         {
            Metadata.FileToFile(MyName);//lê MyName+DataFname, salva MyName+"-dailyreport.csv"
            ShellOpenFile(MyName+"-dailyreport.bat");//chama gnuplot MyName+"-daylyreport.gp"
            if (UseTelegram)
            {
               Sleep(10*1000);
               ThisBot.SendResult();
            }
         }
      }*/
            
      static int tlgrmcnt=0;
      if (UseTelegram)
      {
         if (tlgrmcnt>15)
         {
            ThisBot.Update();
            tlgrmcnt=0;
         }
         else tlgrmcnt++;
      }
   }
   else if ((MQLInfoInteger(MQL_TESTER))&&(!MQLInfoInteger(MQL_OPTIMIZATION)))//tester
   {
      MqlDateTime today;
      TimeLocal(today);
      if ((today.hour>=19)&&(today.min>=0)) Reportdata.SaveToArray();
   }
}

double OnTester()
{
   if (MakePdf&&(MQLInfoInteger(MQL_TESTER))&&(!MQLInfoInteger(MQL_OPTIMIZATION)))//tester
   {
      Reportdata.ArrayToFile();
      //RunGnuplot("plot.gp");
      ShellOpenFile("report.bat");
//      long chartid=ChartOpen("IBOV",PERIOD_D1);
//      ChartSetInteger(chartid,CHART_SHOW,false);

//      CGraphic graphic;
//      graphic.Create(chartid,"Graphic",0,30,30,780,380);
//      double x[]={-10,-4,-1,2,3,4,5,6,7,8};
//      double y[]={-5,4,-10,23,17,18,-9,13,17,4};
//      CCurve *curve=graphic.CurveAdd(x,y,CURVE_LINES);
//      graphic.CurvePlotAll();
//      graphic.Update();

//      GraphPlot(x,y,CURVE_LINES);
            
      //if (FileIsExist("report.pdf",FILE_COMMON)) FileDelete("report.pdf",FILE_COMMON);
      //RunLatex("report.tex");
      
      //while (!FileIsExist("report.pdf",FILE_COMMON)) Sleep(1000);
      //ShellOpenFile("report.pdf");
   }
   return(100.0*TesterStatistics(STAT_BALANCE_DD)/TesterStatistics(STAT_INITIAL_DEPOSIT));
}

void OnDeinit(const int reason)
{
   for (int i=0;i<ArraySize(Assets.data);i++)
   {
      if (UseBook) MarketBookRelease(Assets.data[i].ticker);
      delete Assets.data[i].mydata.Lock;
      delete Assets.data[i].mydata.PosLock;
      delete Assets.data[i].mydata.AssetLock;
      delete Assets.data[i].mydata.StrategyB1;
      delete Assets.data[i].mydata.StrategyS1;
      delete Assets.data[i].mydata.StrategyB2;
      delete Assets.data[i].mydata.StrategyS2;
      delete Assets.data[i].mydata.Liquidity;
      delete Assets.data[i].mydata.PriceMin;      
      delete Assets.data[i].mydata.PosData;      
   }
   EventKillTimer();
}

void OnBookEvent(const string& psymbol)
{
   if (UseBook)
      for (int i=0;i<ArraySize(Assets.data);i++)
         if ((Assets.data[i].selected)&&//chama via onbookevent somente para os selecionados->economia de cpu
            (Assets.data[i].ticker==psymbol)) 
               ontick(Assets.data[i],Money.MarginFree(Assets.data));
   return;
}

void OnTick()
{
   if (SaveData)
   {
      Metadata.DataFname=TimeToString(TimeLocal(),TIME_DATE)+"-data.csv";
      if (!FileIsExist(MyName+Metadata.DataFname))
      {
         int dataoutput=FileOpen(MyName+Metadata.DataFname,FILE_READ|FILE_WRITE|FILE_CSV|FILE_ANSI,';',CP_UTF8);
         FileWrite(dataoutput,"Date",Metadata.SymbolRef,"Equity","Balance","Profit","Positions","Invested",
                              "VolBuy","VolSell","ProfitBuy","ProfitSell","EffBuy","EffSell");      
         FileClose(dataoutput);
      }
      Metadata.Save(MyName);
   }
   //if (Assets.timer.UpdateTime(Forex1,9))
   if (Assets.timer.UpdateTime(Forex1,THour,TMin))
   {
      Print("Ontick:",Assets.timer.LastUpdate," ",TimeLocal());
      Assets.Rank(TableTimeframe,TablePeriod,TableAtrTimeframe,TableAtrPeriod,TablePeriodicity);
      Assets.Select(RSTFixedAssets,Money.Balance()/*,liqfrac,liqper,liqtime,liqrefsymb*/,premin);
      if(UseRenorm) Assets.Renorm(Alavancagem*Money.Balance());
      Assets.timer.SetLastUpdate(9);
      for (int i=0;i<ArraySize(Assets.data);i++)
      {
         Assets.data[i].mydata.StrategyB1.myvol=Assets.data[i].vol;
         Assets.data[i].mydata.StrategyB2.myvol=Assets.data[i].vol;
         Assets.data[i].mydata.StrategyS1.myvol=Assets.data[i].vol;
         Assets.data[i].mydata.StrategyS2.myvol=Assets.data[i].vol;
      }
      Assets.PrintTable();
      if((!MQLInfoInteger(MQL_OPTIMIZATION))&&(!MQLInfoInteger(MQL_TESTER)))
      {
         Assets.SaveConfig(MyName+".bin");
      }
      if (SaveTable) Assets.SaveTable(MyName+"-carteira.csv");
   }
   
   if (UseTimer&&(ThisTimer.UpdateTime(Forex1,OHour,OMin)))
   {
      for (int i=0;i<ArraySize(Assets.data);i++)
         if (Assets.data[i].selected||PositionSelect(Assets.data[i].ticker))//só chama se for selecionado ou se tiver posição 
            ontick(Assets.data[i],Money.MarginFree(Assets.data));//para permitir o fechamento de posições fora da tabela
      ThisTimer.SetLastUpdate();
   }
   else if (!UseTimer)
   {   
      for (int i=0;i<ArraySize(Assets.data);i++) 
         if (Assets.data[i].selected||PositionSelect(Assets.data[i].ticker)) 
            ontick(Assets.data[i],Money.MarginFree(Assets.data));//chama para todos, para permitir o fechamento de posições fora da tabela
   }

   return;
}

void NONE(void){return;}

void ontick(AssetData &data,double FreeMargin)
{
   string psymbol=data.ticker;
   CLock* lock=data.mydata.Lock;
   PLock* poslock=data.mydata.PosLock;
   ALock* assetlock=data.mydata.AssetLock;
   Signal* StrategyB1=data.mydata.StrategyB1;
   Signal* StrategyB2=data.mydata.StrategyB2;
   Signal* StrategyS1=data.mydata.StrategyS1;
   Signal* StrategyS2=data.mydata.StrategyS2;
   Filters* Liquidity=data.mydata.Liquidity;
   Filters* PriceMin=data.mydata.PriceMin;
   OrderData* PosData=data.mydata.PosData;
  
   double VolLimitFrac=VolLimit*TimerPeriod*4/Dia;//O 4 é por causa da duração do pregão
   if (!UseVolLimit) VolLimitFrac=1;
      
   if (Bars(psymbol,PERIOD_D1)<10) return;
   MqlDateTime today,stime,ltime;
   TimeCurrent(today);
   TimeLocal(ltime);
   MqlRates rttemp[];
   ArraySetAsSeries(rttemp,true);
   CopyRates(psymbol,PERIOD_D1,0,1,rttemp);
   TimeToStruct(rttemp[0].time,stime);

   if (!Forex1&&((today.day!=ltime.day)||(today.day!=stime.day))) return;
   
   bool not_locked=lock.CheckLock(psymbol,LockExp);//essa trava destrava se tem pendente
   bool isonline=(!MQLInfoInteger(MQL_TESTER))&&(!MQLInfoInteger(MQL_OPTIMIZATION));
   bool auction=(SymbolInfoDouble(psymbol,SYMBOL_ASK)<=SymbolInfoDouble(psymbol,SYMBOL_BID));
   bool possel=PositionSelect(psymbol);
   //int MyMagic=-100;
   bool pending=CheckOrders(psymbol,ALL_LOCKS);

   bool assetnotlocked=false;
   if (isonline&&UseAssetLock&&(!pending))//reseta a trava de ativos. Só reseta se não tem posição. Mas e se tiver pendente?
   {
      if (!possel) assetlock.ResetLock();
      assetnotlocked=assetlock.CheckLock(EAMAGIC);
   }
   else assetnotlocked=true;//testing e optimization

   if (possel&&data.selected&&isonline&&PosTake&&UseAssetLock&&(!pending))//tomada de posição //Só se tiver posição. Mas e se tiver pendente?
      if (assetlock.CheckPosTake(EAMAGIC)) 
         assetlock.SetPosTake(EAMAGIC);

//Reseta position data se não tem ordem, nem posição, nem trava e o ativo é meu e usamos ordens pendentes para alguma coisa
   if ((!possel)&&(!pending)&&(not_locked)
      &&((UseAssetLock&&isonline)?assetlock.CheckOwner(EAMAGIC):true)&&
      (UsePendingClose||UsePendingOpen||UsePendingSl||UsePendingTp))
   {
      double sl,tp,priceref,atr,target;
      datetime lasttime;
      OrderTypes ot;
      PosData.GetPositionData(sl,tp,ot,priceref,atr,target,lasttime);
      if (ot!=OTNone) PosData.Reset();
   }
   
   //if (possel&&assetnotlocked)
   if (possel&&(!pending)&&((UseAssetLock&&isonline)?assetlock.CheckOwner(EAMAGIC):true)
         &&(Forex1?true:(((today.hour>=OHour)&&(today.min>=OMin))||(today.hour>=(OHour+1))))//horário de abertura
         &&(!auction)
         &&TerminalInfoInteger(TERMINAL_CONNECTED)//conectado
         &&TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)//negociação habilitada
         )//só mexa na posição se ela for minha e não tiver pendentes
   {
      poslock.SetLock();
      if ((not_locked)&&(!data.selected))//ativo não selecionado 
      {
         if (UsePendingClose)
         {
            double sl,tp,priceref,atr,target;
            datetime lasttime;
            OrderTypes ot;
            PosData.GetPositionData(sl,tp,ot,priceref,atr,target,lasttime);
            double bid=SymbolInfoDouble(psymbol,SYMBOL_BID),ask=SymbolInfoDouble(psymbol,SYMBOL_ASK);
            if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) priceref=ask;//atr=Atr(psymbol,StrategyB1.patr,StrategyB1.timeframe);}
            else if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL) priceref=bid;//atr=Atr(psymbol,StrategyS1.patr,StrategyS1.timeframe);}           
            //TODO: set the target
            if (PosData.SetPositionData(sl,tp,OTClose,priceref,atr,target,TimeLocal()))
            {
               MyPrint("Fechando "+psymbol);
               PositionClose(true,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
               MyPrint("Posição fora do ranking ");         
            }
            else MyPrint("Erro fechando "+psymbol);
            return;
         }
         else
         {
            MyPrint("Fechando "+psymbol);
            PositionClose(false,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
            MyPrint("Posição fora do ranking ");                  
         }         
      }         
      if (not_locked)//verifica se atingiu (pulou) sl/tp - neste caso, como o sl e o tp estão na posição, o protocolo é fechar imediatamente
      //é possível pensar em uma rotina para o caso em que usamos ordens pendentes, nesse caso a informação sobre o sl tp teria que vir de algum
      //lugar como o comentário da ordem ou consulta à estratégia. Pode ser aqui o lugar ideal para implementar isso
      {
         double sl=PositionGetDouble(POSITION_SL);
         double tp=PositionGetDouble(POSITION_TP);
         double priceref=0,atr=0,target=0;
         datetime lasttime=0;
         OrderTypes ot=OTNone;
         if (UsePendingSl||UsePendingTp) PosData.GetPositionData(sl,tp,ot,priceref,atr,target,lasttime);
         double last=rttemp[0].close;
         double bid=SymbolInfoDouble(psymbol,SYMBOL_BID),ask=SymbolInfoDouble(psymbol,SYMBOL_ASK);
         if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) priceref=ask;
         else if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL) priceref=bid;
         //TODO: set the target             
         if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
         {
            if ((UsePendingSl)&&(last<=sl)&&(sl!=0))//stop loss
            {
               if (PosData.SetPositionData(sl,tp,OTSL,priceref,atr,target,TimeLocal()))
               { 
                  PositionClose(true,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
                  MyPrint("Fechando posição Buy, condição de sl atingida ",DoubleToString(last,2)," ",DoubleToString(sl,2)," ",DoubleToString(tp,2));         
               }
            }
            else if ((UsePendingTp)&&(last>=tp)&&(tp!=0))//take profit
            {
               if (PosData.SetPositionData(sl,tp,OTTP,priceref,atr,target,TimeLocal())) 
               {
                  PositionClose(true,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
                  MyPrint("Fechando posição Buy, condição de tp atingida ",DoubleToString(last,2)," ",DoubleToString(sl,2)," ",DoubleToString(tp,2));         
               }
            }
            else if ( ((last>tp)&&(tp!=0)) || ((last<sl)&&(sl!=0)) )//vefirica se o sl/tp foi pulado
            {
               PositionClose(false,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
               MyPrint("Fechando posição Buy, condição de sl/tp pulada ",DoubleToString(last,2)," ",DoubleToString(sl,2)," ",DoubleToString(tp,2));         
            }
            return;         
         }         
         if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
         {
            if ((UsePendingSl)&&(last>=sl)&&(sl!=0))//stop loss
            {
               if (PosData.SetPositionData(sl,tp,OTSL,priceref,atr,target,TimeLocal()))
               { 
                  PositionClose(true,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
                  MyPrint("Fechando posição Sell, condição de sl atingida ",DoubleToString(last,2)," ",DoubleToString(sl,2)," ",DoubleToString(tp,2));         
               }
            }
            else if ((UsePendingTp)&&(last<=tp)&&(tp!=0))//take profit
            {
               if (PosData.SetPositionData(sl,tp,OTTP,priceref,atr,target,TimeLocal())) 
               {
                  PositionClose(true,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
                  MyPrint("Fechando posição Sell, condição de tp atingida ",DoubleToString(last,2)," ",DoubleToString(sl,2)," ",DoubleToString(tp,2));         
               }
            }
            else if ( ((last<tp)&&(tp!=0)) || ((last>sl)&&(sl!=0)) )//vefirica se o sl/tp foi pulado
            {
               PositionClose(false,psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
               MyPrint("Fechando posição Sell, condição de sl/tp atingida ",DoubleToString(last,2)," ",DoubleToString(sl,2)," ",DoubleToString(tp,2));         
            }
            return;         
         }
      }      
      //MyMagic=(int)PositionGetInteger(POSITION_MAGIC);
      //if (MyMagic==StrategyB1.BuyMagic)//modifica sl/tp, checa day trade
      if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
      {
            if (PosExp) if (ExpiraPos(UsePendingClose,PosData,psymbol,PosExpB,not_locked,lock,UseVolLimit,VolLimitFrac,data.mvol)) return;
            ModifySlTp(psymbol,Atr(psymbol,StrategyB1.patr,StrategyB1.timeframe),PosExp,PosExpB,Buy,UseTrailingSL,UseTrailingTP,PosExpTP,PosExpSL,
            Sl_Type,SLLevel,SlTimeframe,SlBars,
            Tp_Type,TPLevel,TpTimeframe,TpBars,
            lock,not_locked,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_TP),UsePendingSl,UsePendingTp);//só chama se não for usependingsltp
            if (UseDTB) CheckDT(possel,psymbol,not_locked,lock,UseVolLimit,VolLimitFrac,data.mvol);//não fechar usando pendentes
      }
      else if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
      //else if (MyMagic==StrategyS1.SellMagic)//modifica sl/tp, checa day trade
      {
            if (PosExp) if (ExpiraPos(UsePendingClose,PosData,psymbol,PosExpS,not_locked,lock,UseVolLimit,VolLimitFrac,data.mvol)) return;
            ModifySlTp(psymbol,Atr(psymbol,StrategyS1.patr,StrategyS1.timeframe),PosExp,PosExpS,Sell,UseTrailingSL,UseTrailingTP,PosExpTP,PosExpSL,
            Sl_Type,SLLevel,SlTimeframe,SlBars,
            Tp_Type,TPLevel,TpTimeframe,TpBars,
            lock,not_locked,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_TP),UsePendingSl,UsePendingTp);//,(UsePendingClose||UsePendingOpen||UsePendingSLTP),PosData);
            if (UseDTS) CheckDT(possel,psymbol,not_locked,lock,UseVolLimit,VolLimitFrac,data.mvol);//não fechar usando pendentes
      }
      /*else//Há uma posição sem o magic correto. Feche-a imediatamente
      {
            if ((not_locked)&&(MyMagic!=CLOSE_LOCK)) 
            {
               PositionClose(psymbol,lock,UseVolLimit,VolLimitFrac,data.mvol);
               Print("Erro! Posição sem o magic correto "+IntegerToString(MyMagic));         
            }         
            return;         
      }*/
   }

   if ( ((today.hour>=OCHour)&&(today.min>=OCMin))||(today.hour>(OCHour)) )
   {
      StrategyB1.Reset();
      StrategyS1.Reset();
      StrategyB2.Reset();
      StrategyS2.Reset();
   }
   
   if (possel&&pending)/*&&(!PersistSignal)*///se tem posição ou tem pendente, reseta o sinal
   { 
      if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) {StrategyB1.Reset();StrategyB2.Reset();}
      if (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL) {StrategyS1.Reset();StrategyS2.Reset();}
   }

   bool position_not_locked=poslock.CheckLock(psymbol,LockExp);//trava de posição retorna false se travado.
   
   //Print(psymbol," ",count_stops(psymbol,DEAL_TYPE_SELL,StrategyB1.BuyMagic)," ",count_stops(psymbol,DEAL_TYPE_BUY,StrategyS1.SellMagic));

   if ((not_locked)&&(!pending)//só abre nova se não tiver pendente
      &&assetnotlocked
      &&data.selected
      &&(Forex1?true:(((today.hour>=OHour)&&(today.min>=OMin))||(today.hour>=(OHour+1))))//horário de abertura
      &&(!auction)//evita leilão
      &&TerminalInfoInteger(TERMINAL_CONNECTED)//conectado
      &&TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)//negociação habilitada
      )
   {      
      if (EnableB&&(possel?
            ((UseCloseBy&&(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL))||
            ((PositionGetDouble(POSITION_VOLUME)!=data.vol)&&(UseRebal)))
            :position_not_locked)//se não tem posição, só abre nova se não tiver trava de posição
        &&StrategyB1.SignalCheck(Buy)
        &&(possel?true:StrategyB2.SignalCheck(Buy))//só checa o sinal da segunda estratégia se não tiver posição
        &&(!(UseDTB?CheckDT(false,psymbol,not_locked,lock,UseVolLimit,VolLimitFrac,data.mvol):false))
        &&(count_stops(psymbol,DEAL_TYPE_SELL,StrategyB1.BuyMagic)<1)
        &&(possel?true:(UseFilter1?(!Liquidity.Filter(Buy)):true))//só checa os filtros se não tiver posição
        &&(possel?true:(UseFilter2?(!PriceMin.Filter(Buy)):true))
        &&(possel?true:(MGMTMargin?(FreeMargin>=(data.vol*rttemp[0].close)):true))//só checa margem se não tiver posição
         )
      {
         if ((possel)&&(UseCloseBy)) Trade.PositionClose(psymbol);//não usar pendente
         double myvol=TradeSizeOptimized(psymbol,StrategyB1.Vol(),true);
         if (UseVolLimit&&(myvol>(VolLimitFrac*data.mvol))) myvol=TradeSizeOptimized(psymbol,VolLimitFrac*data.mvol,true);//limita o volume a x% da média

         if ((UseAssetLock&&isonline)?assetlock.SetLock(EAMAGIC):true)
         {
            if (UsePendingOpen)
            {
               //TODO: set the target
               if (PosData.SetPositionData(StrategyB1.Sl(),StrategyB1.Tp(),OTOpen,SymbolInfoDouble(psymbol,SYMBOL_BID),Atr(psymbol,StrategyB1.patr,StrategyB1.timeframe,0),0,TimeLocal()))
                  if (open_buy(psymbol,Atr(psymbol,StrategyB1.patr,StrategyB1.timeframe,0),myvol,
                           Sl_Type,SLLevel,SlTimeframe,SlBars,
                           Tp_Type,TPLevel,TpTimeframe,TpBars,
                           "Buy ",(possel?(int)PositionGetInteger(POSITION_MAGIC):StrategyB1.BuyMagic),
                           UsePendingOpen,OrderSlippage,
                           lock,
                           StrategyB1.Sl(),
                           StrategyB1.Tp()))
                     return;
            }
            else
            {
               if (open_buy(psymbol,Atr(psymbol,StrategyB1.patr,StrategyB1.timeframe,0),myvol,
                        Sl_Type,SLLevel,SlTimeframe,SlBars,
                        Tp_Type,TPLevel,TpTimeframe,TpBars,
                        "Buy ",(possel?(int)PositionGetInteger(POSITION_MAGIC):StrategyB1.BuyMagic),
                        UsePendingOpen,OrderSlippage,
                        lock,
                        StrategyB1.Sl(),
                        StrategyB1.Tp()))
                  return;
            }
         }
      }

      if (EnableS&&(possel?
               ((UseCloseBy&&(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY))||
               ((PositionGetDouble(POSITION_VOLUME)!=data.vol)&&(UseRebal)))
               :position_not_locked)
        &&StrategyS1.SignalCheck(Sell)
        &&(possel?true:StrategyS2.SignalCheck(Sell))//só checa o sinal da segunda estratégia se não tiver posição
        &&(!(UseDTS?CheckDT(false,psymbol,not_locked,lock,UseVolLimit,VolLimitFrac,data.mvol):false))
        &&(count_stops(psymbol,DEAL_TYPE_BUY,StrategyS1.SellMagic)<1)
        &&(possel?true:(UseFilter1?(!Liquidity.Filter(Sell)):true))//só checa os filtros se não tiver posição
        &&(possel?true:(UseFilter2?(!PriceMin.Filter(Sell)):true))
        &&(possel?true:(MGMTMargin?(FreeMargin>=(data.vol*rttemp[0].close)):true))//só checa margem se não tiver posição
         )
      {
         if ((possel)&&(UseCloseBy)) Trade.PositionClose(psymbol);//não usar pendente
         double myvol=TradeSizeOptimized(psymbol,StrategyS1.Vol(),true);
         if (UseVolLimit&&(myvol>(VolLimitFrac*data.mvol))) myvol=TradeSizeOptimized(psymbol,VolLimitFrac*data.mvol,true);//limita o volume a x% da média

         //myvol=TradeSizeOptimized(psymbol,StrategyS1.Vol()/2.0,false);//parcela a ordem
         //Print(assetlock.SetLock(EAMAGIC)," ",psymbol);
         if ((UseAssetLock&&isonline)?assetlock.SetLock(EAMAGIC):true)
         {
            if (UsePendingOpen)
            {
               //TODO: set the target
               if(PosData.SetPositionData(StrategyS1.Sl(),StrategyS1.Tp(),OTOpen,SymbolInfoDouble(psymbol,SYMBOL_ASK),Atr(psymbol,StrategyS1.patr,StrategyS1.timeframe,0),0,TimeLocal()))
                  if (open_sell(psymbol,Atr(psymbol,StrategyS1.patr,StrategyS1.timeframe,0),myvol,
                              Sl_Type,SLLevel,SlTimeframe,SlBars,
                              Tp_Type,TPLevel,TpTimeframe,TpBars,
                              "Sell ",(possel?(int)PositionGetInteger(POSITION_MAGIC):StrategyS1.SellMagic),
                              UsePendingOpen,OrderSlippage,
                              lock,
                              StrategyS1.Sl(),
                              StrategyS1.Tp()))
                     return;
            }
            else
            {
               if (open_sell(psymbol,Atr(psymbol,StrategyS1.patr,StrategyS1.timeframe,0),myvol,
                           Sl_Type,SLLevel,SlTimeframe,SlBars,
                           Tp_Type,TPLevel,TpTimeframe,TpBars,
                           "Sell ",(possel?(int)PositionGetInteger(POSITION_MAGIC):StrategyS1.SellMagic),
                           UsePendingOpen,OrderSlippage,
                           lock,
                           StrategyS1.Sl(),
                           StrategyS1.Tp()))
                  return;
            }
         }
      }
   }

   if (pending)
   {
      PosData.CheckPendingExpiration(OrdExp,auction);//verifica expiração da pendente e deleta
      if ((UseTrailingOp)&&(PosData.order_type==OTOpen))
         PosData.OrderTrailing(TrailingTopOp,TrailingMountainOp,TrailingSoma1Op,TrailingEscapeOp,TrailingTargetOp,TrailingTolOp,TrailingTolFracOp,TrailingAggressionOp);
      else if ((UseTrailingCl)&&(PosData.order_type==OTClose))
         PosData.OrderTrailing(TrailingTopCl,TrailingMountainCl,TrailingSoma1Cl,TrailingEscapeCl,TrailingTargetCl,TrailingTolCl,TrailingTolFracCl,TrailingAggressionCl);
      else if ((UseTrailingSl)&&(PosData.order_type==OTSL))
         PosData.OrderTrailing(TrailingTopSl,TrailingMountainSl,TrailingSoma1Sl,TrailingEscapeSl,TrailingTargetSl,TrailingTolSl,TrailingTolFracSl,TrailingAggressionSl);
      else if ((UseTrailingTp)&&(PosData.order_type==OTTP))
         PosData.OrderTrailing(TrailingTopTp,TrailingMountainTp,TrailingSoma1Tp,TrailingEscapeTp,TrailingTargetTp,TrailingTolTp,TrailingTolFracTp,TrailingAggressionTp);
   }      
   return;
}

void InitStrategy(Signal* &strategy,MODEL_TYPES EModelType,string Asymbol,int EPAtrB,ENUM_TIMEFRAMES ETimeFrameB,
                  REF_TYPES EType,REF_PRICES_TYPES EPrice,int EPeriodo,ENUM_TIMEFRAMES ERefTimeFrame,double EAtrFrac,bool EConfCandle,double volume)
{
   switch (EModelType)
   {
      case Buy_hold:
      {
         strategy=new BuyHold;
         strategy.Init();
         strategy.Initfixed(Asymbol,EPAtrB,ETimeFrameB,BUY_HOLD_MAGIC,BUY_HOLD_MAGIC+1,volume);
         break;
      }
      case Buy_hold_sell_neutral:
      {
         strategy=new BuyHoldSellNeutral;
         strategy.Init();
         strategy.Initfixed(Asymbol,EPAtrB,ETimeFrameB,BUY_HOLD_MAGIC,BUY_HOLD_MAGIC+1,volume);
         break;
      }
      case Sell_hold:
      {
         strategy=new SellHold;
         strategy.Init();
         strategy.Initfixed(Asymbol,EPAtrB,ETimeFrameB,SELL_HOLD_MAGIC,SELL_HOLD_MAGIC+1,volume);
         break;
      }
      case Tendencia:
      {
         strategy=new Trend;
         strategy.Init();
         strategy.Initfixed(Asymbol,EPAtrB,ETimeFrameB,TREND_MAGIC,TREND_MAGIC+1,volume);
         double params[6];
         params[0]=(double)EType;
         params[1]=(double)EPrice;
         params[2]=(double)EPeriodo;
         params[3]=(double)EAtrFrac;
         params[4]=(double)EConfCandle;
         params[5]=(double)ERefTimeFrame;
         strategy.Initspecific(params);
         break;
      }
      case Retorno:
      {
         strategy=new Return;
         strategy.Init();
         strategy.Initfixed(Asymbol,EPAtrB,ETimeFrameB,RETURN_MAGIC,RETURN_MAGIC+1,volume);
         double params[6];
         params[0]=(double)EType;
         params[1]=(double)EPrice;
         params[2]=(double)EPeriodo;
         params[3]=(double)EAtrFrac;
         params[4]=(double)EConfCandle;
         params[5]=(double)ERefTimeFrame;
         strategy.Initspecific(params);
         break;
      }
      case Gap_alta_baixa:
      {
         strategy=new Gap;
         strategy.Init();
         strategy.Initfixed(Asymbol,EPAtrB,ETimeFrameB,GAP_MAGIC,GAP_MAGIC+1,volume);
         break;
      }
      case Python_scripts:
      {
         strategy=new PythonScripts;
         strategy.Init();
         strategy.Initfixed(Asymbol,EPAtrB,ETimeFrameB,PYTHON_MAGIC,PYTHON_MAGIC+1,volume);
         strategy.InitFname(python_fname);
         double params[2];
         params[0]=(double)UsePythonTicker;//useticker
         params[1]=(double)UsePythonVolume;//usevolume
         break;
      }
   }
}


int OnInit()
{
   if (UseNeutralization)
   {
      MyTickers[ArraySize(MyTickers)-1]=NeutralAsset2;
      MyTickers[ArraySize(MyTickers)-2]=NeutralAsset1;
   }
   //Sleep(60*1000);//bug no reinício do metatrader
   srand(SeedMonteCarlo);
   Trade.SetAsyncMode(false);
   MyName=EAName+"-Avalon";//+StringSubstr(TableFile,0,4);
   Money.mgmt=MGMTType;
   Money.MyCapital=mycapital;
   Money.MyMargin=mymargin;
   Money.MyMarginFrac=mymarginfrac;
   if ((FileIsExist(MyName+".bin"))&&(!MQLInfoInteger(MQL_OPTIMIZATION))&&(!MQLInfoInteger(MQL_TESTER)))
   {
      Assets.LoadConfig(MyName+".bin");
      if (ChangeCapital)
      {
         Assets.Redim(Alavancagem*Money.Balance());
         Assets.timer.SetLastUpdate(9);
         Assets.PrintTable();      
         if((!MQLInfoInteger(MQL_OPTIMIZATION))&&(!MQLInfoInteger(MQL_TESTER))) Assets.SaveConfig(MyName+".bin");
         if (SaveTable) Assets.SaveTable(MyName+"-carteira.csv");
      }
      Print(Assets.timer.LastUpdate," ",TimeLocal());
   }
   else
   {
      Assets.timer.Periodicidade=TablePeriodicity;
      Assets.MyRankSelection=MySelectionType;//RSTFixed;//RSTCharge;//RSTPositive;
      Assets.MyRank=MyRank;
      Assets.UseLiqFilter=UseTableLiqFilter;
      Assets.UsePreFilter=UseTablePreFilter;
      Assets.UseLowVolFilter=UseTableLowVolFilter;
           
      //Assets.Read(TableFile,EnableMonteCarlo,NativosMonteCarlo);//ativos[0]=Symbol();
      Assets.Read(EnableMonteCarlo,NativosMonteCarlo);//ativos[0]=Symbol();
      Assets.Rank(TableTimeframe,TablePeriod,TableAtrTimeframe,TableAtrPeriod,TablePeriodicity);
      Assets.Select(RSTFixedAssets,Money.Balance()/*,liqfrac,liqper,liqtime,liqrefsymb*/,premin);
      if(UseRenorm) Assets.Renorm(Alavancagem*Money.Balance());
      Assets.timer.SetLastUpdate(9);
      //Assets.timer.LastUpdate=Assets.timer.Periodicidade*(datetime)floor(TimeLocal()/Assets.timer.Periodicidade);
      Assets.PrintTable();      
      if((!MQLInfoInteger(MQL_OPTIMIZATION))&&(!MQLInfoInteger(MQL_TESTER)))
      {
         Assets.SaveConfig(MyName+".bin");//deve ter uma opção para salvar a configuração
      }
      //if (SaveTable) Assets.SaveTable(MyName+"-"+TimeToString(TimeCurrent(),TIME_DATE)+"-carteira.csv");
      if (SaveTable) Assets.SaveTable(MyName+"-carteira.csv");
   }

   for(int i=0;i<ArraySize(Assets.data);i++)
   {
      string Asymbol=Assets.data[i].ticker;

      Assets.data[i].mydata.Lock=new CLock;
      Assets.data[i].mydata.Lock.ResetLock();
      Assets.data[i].mydata.PosLock=new PLock;
      Assets.data[i].mydata.PosLock.ResetLock();
      Assets.data[i].mydata.AssetLock=new ALock;
      if ((!MQLInfoInteger(MQL_TESTER))&&(!MQLInfoInteger(MQL_OPTIMIZATION))&&UseAssetLock)
         Assets.data[i].mydata.AssetLock.InitLock(Asymbol);

      if (UseBook) MarketBookAdd(Asymbol);
      InitStrategy(Assets.data[i].mydata.StrategyB1,E1ModelType,Asymbol,E1PAtrB,E1TimeFrameB,E1Type,E1Price,E1Periodo,E1RefTimeFrame,E1AtrFrac,E1ConfCandle,Assets.data[i].vol);
      InitStrategy(Assets.data[i].mydata.StrategyS1,E1ModelType,Asymbol,E1PAtrS,E1TimeFrameS,E1Type,E1Price,E1Periodo,E1RefTimeFrame,E1AtrFrac,E1ConfCandle,Assets.data[i].vol);
      InitStrategy(Assets.data[i].mydata.StrategyB2,E2ModelType,Asymbol,E2PAtrB,E2TimeFrameB,E2Type,E2Price,E2Periodo,E2RefTimeFrame,E2AtrFrac,E2ConfCandle,Assets.data[i].vol);
      InitStrategy(Assets.data[i].mydata.StrategyS2,E2ModelType,Asymbol,E2PAtrS,E2TimeFrameS,E2Type,E2Price,E2Periodo,E2RefTimeFrame,E2AtrFrac,E2ConfCandle,Assets.data[i].vol);
      
      Assets.data[i].mydata.Liquidity=new Filters;
      Assets.data[i].mydata.Liquidity.symbol=Asymbol;
      Assets.data[i].mydata.Liquidity.myfilter=MyFilter1;
      Assets.data[i].mydata.Liquidity.FTLiqFrac=LiqFrac1;
      Assets.data[i].mydata.Liquidity.FTPeriod=FPeriod1;
      Assets.data[i].mydata.Liquidity.FTTimeframe=FTimeFrame1;
      Assets.data[i].mydata.Liquidity.FTLiqSymbolref=FSymbol1;
   
      Assets.data[i].mydata.PriceMin=new Filters;
      Assets.data[i].mydata.PriceMin.symbol=Asymbol;
      Assets.data[i].mydata.PriceMin.myfilter=MyFilter2;
      Assets.data[i].mydata.PriceMin.FTPreMin=PreMin2;

      Assets.data[i].mydata.PosData=new OrderData;
      if (UsePendingClose||UsePendingOpen||UsePendingSl||UsePendingTp) Assets.data[i].mydata.PosData.InitPositionData(Asymbol);
   }  


   ThisTimer.Periodicidade=TimerPeriod;

   Metadata.timer.Periodicidade=SaveDataPeriod;
   Metadata.SymbolRef=SaveSymbolRef;//Symbol();
   Metadata.DataFname=TimeToString(TimeLocal(),TIME_DATE)+"-data.csv";
   if (!FileIsExist(MyName+Metadata.DataFname))
   {
      int dataoutput=FileOpen(MyName+Metadata.DataFname,FILE_READ|FILE_WRITE|FILE_CSV|FILE_ANSI,';',CP_UTF8);
      FileWrite(dataoutput,"Date",Metadata.SymbolRef,"Equity","Balance","Profit","Positions","Invested",
                           "VolBuy","VolSell","ProfitBuy","ProfitSell","EffBuy","EffSell");      
      FileClose(dataoutput);
   }
   
   if ((!MQLInfoInteger(MQL_TESTER))&&(!MQLInfoInteger(MQL_OPTIMIZATION))) EventSetTimer(1);//online
   else if (MakePdf&&(MQLInfoInteger(MQL_TESTER))&&(!MQLInfoInteger(MQL_OPTIMIZATION))) //grava report
   {
      EventSetTimer(4*3600);
      Reportdata.timer.Periodicidade=Dia;
      Reportdata.SymbolRef=SaveSymbolRef;
      Reportdata.DataFname="report.csv";
   }
   
   if (UseTelegram)
   {
      int datatoken=FileOpen(EAName+"Token.txt",FILE_READ|FILE_TXT);
      ThisBot.Init(FileReadString(datatoken));
      FileClose(datatoken);
   }

   Print("Init finished");
   return(INIT_SUCCEEDED);
}