//+------------------------------------------------------------------+
//|                                                GT - Breakout.mq5 |
//|                                    Copyright 2022, GESTÃO TRADER |
//|                                     https://www.gestaotrader.com |
//+------------------------------------------------------------------+
#property copyright "GESTÃO TRADER"
#property link      "https://www.gestaotrader.com"
#property version   "2.6"
#property description "Robô Trader Navy Seal"
#property description "—————————————————————————"
#property description "GESTÃO TRADER | Xayer L. Xavier"
#property description "xayerxavier@hotmail.com" 
#property description "Whatsapp (62) 99433-1331"
#property description " "
#property description "Estratégia desenvolvida por Xayer L. Xavier"
#property description "Programação por: Everson Mayer, Hugo Gava | 2022-2023"
#property icon        "\\Images\\Icone_Gestao_Trader.ico"
//+------------------------------------------------------------------+
//| INCLUSÔES                                                        |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <Trade\Trade.mqh>
//#include <JAson.mqh>

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                           CONTROLE                               |
//|                              DE                                  |
//|                            ACESSO                                |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+


const int     NUMERO_MAXIMO_CONTRATOS = 100;
const string  NOME_NA_CORRETORA = "XAYER LINO XAVIER";
const long    NUMERO_CONTA_REAL = 1;      
const long    NUMERO_CONTA_DEMO = 3008889245;      
const int     DIA_DO_VENCIMENTO = 30;
const int     MES_DO_VENCIMENTO = 6;
const int     ANO_DO_VENCIMENTO = 2050;


//+------------------------------------------------------------------+
//| OUTRAS CONSTANTES                                                       |
//+------------------------------------------------------------------+

string NOME_NUMERO_MAGICO = "NUMERO_MAGICO";
const int SEGUNDOS_TIMER = 4;
const string NOME_ROBO = MQLInfoString(MQL_PROGRAM_NAME);

//+------------------------------------------------------------------+
//| ENUM                                                             |
//+------------------------------------------------------------------+

enum MODO_CONTA
  {

   mcNETTING = 0, //Netting
   mcHEDGING = 1, //Hedge

  };

enum FILTRO_MEDIAS
  {
   UmaMedia = 0,  // Acima/Abaixo da Média PEQUENA
   DuasMedias = 1, // Acima/Abaixo de DUAS Médias
   TresMedias = 2, // Acima/Abaixo de TRÊS Médias
   SemMedias = 3, // Sem Médias (Gráfico Puro)
   LequeTresMedias = 4, // Leque de TRÊS Médias
  };
  
enum TIPOS_DE_CONTRATO
   {
   MiniIndice = 0, //Mini Indice
   IndiceCheio = 1, // Indice Cheio
   MiniDolar = 2, //Mini Dólar
   DolarCheio = 3, // Dólar Cheio
   OutrosAtivos = 4, //Outros Ativos (ATIVO CORRENTE)
   };
   
   
enum TIPOS_DE_POSITIONSIZE
   {
   PorcentagemConta = 0, //Porcentagem do Saldo em Conta
   RFixo = 1, // Valor de R fixo
   LoteFixo = 2, //Lote Fixo
   };
   
enum REAL_OU_BACKTEST
   {
   ContaReal = 0, //Conta REAL
   Backtest = 1, //BackTest
   };
   
enum TRALING_STOP
   {
   Ativa_TralingStop = 0, //Traling Stop ATIVADO
   Desativa_TralingStop = 1, //Traling Stop DESATIVADO
   };
   
enum PORCENTAGEM_DA_CONTA
   {
   PorcentagemConta1_0 = 0, //1.0%
   PorcentagemConta1_5 = 1, //1.5%
   PorcentagemConta2_0 = 2, //2.0%
   PorcentagemConta2_5 = 3, //2.5%
   PorcentagemConta3_0 = 4, //3.0%
   PorcentagemConta4_0 = 5, //4.0%
   PorcentagemConta5_0 = 6, //5.0%
   PorcentagemConta10_0 = 7, //10.0%
   PorcentagemConta15_0 = 8, //15.0%
   PorcentagemConta20_0 = 9, //20.0%
   };

enum ROTEAMENTO
   {
   Mini_Indice = 0, //Mini Indice (ATIVO CORRENTE)
   Indice_Cheio = 1, // Indice Cheio (ATIVO CORRENTE)
   Mini_Dolar = 2, //Mini Dólar (ATIVO CORRENTE)
   Dolar_Cheio = 3, // Dólar Cheio (ATIVO CORRENTE)
   OutrosAtivos = 4, //Outros Ativos (ATIVO CORRENTE)
   };
   
enum COMENTARIOS_ROBO
   {
   Sim_MostrarOsComentarios = 0, //Sim, mostrar os comentários/variáveis do robô
   Nao_MostrarOsComentarios = 1, //Não mostrar os comentários/variáveis do robô
   };

enum INPUT_ALVO_MIN_ENTRADA
  {
   Alvo_Pela_Minima_Ou_Maxima = 0,  // pela Mínima/Máxima
   Alvo_Pela_Entrada = 1, // pela Entrada

  };
  
enum INPUT_ATR_DIARIO_X_PERIODOS
  {
   Habilitado_Atr_Diario = 0,  // Só opera se o ATR Diário de XX períodos for maior que XX pontos
   Desabilitado_Atr_Diario = 1, // Desabilita o filtro do ATR Diário, opera em qq circunstância

  };
//+------------------------------------------------------------------+
//|  INPUTS                                                          |
//+------------------------------------------------------------------+
input group "■■■■■ CONFIGURAÇÕES POSITIONSIZE ↓"
input TIPOS_DE_POSITIONSIZE inputPorcentagemConta = RFixo; // Escolha modo de Positionsize
input string ————————————————————— = "———————————————————————————";
input PORCENTAGEM_DA_CONTA inputPorcentagemConta1_5 = PorcentagemConta1_5; // Porcentagem da conta
input int valorDoREmReais = 1000; //Valor do R | Risco Financeiro em Reais
input int quantidadeDeContratosFixo = 3; //Quantidade de contratos fixo
input group "■■■■■ TIPO DE CONTRATO ↓"
input TIPOS_DE_CONTRATO inputTipoContrato = MiniIndice; //Pegar Dados Do Seguinte Ativo
input ROTEAMENTO inputCrossOrder = Mini_Indice; //Rotear Ordens no Seguinte Ativo
input string inputQualTickerAtivo = ""; //Qual TICKER DO ATIVO? Ex: WINQ23
input group "■■■■■ TIPO DE CONTA E OPORTUNIDADES NO DIA ↓"
sinput REAL_OU_BACKTEST inputModoDeMercado = ContaReal; //Conta Real ou Backtest??
sinput MODO_CONTA inputModoConta = mcHEDGING; //Tipo de Conta
input ulong VALOR_NUMERO_MAGICO = 1000;
input int inputMaximoTradesNoDia = 1;
input group "■■■■■ COMENTÁRIOS E HORÁRIO DE OPERAÇÃO ↓"
input COMENTARIOS_ROBO inputMostrarComentarios = Sim_MostrarOsComentarios; //Mostrar Comentários na tela?
sinput string inputHoraInicialAbrirPosicao = "09:05"; //Começa a fazer trade às XX h ?
sinput string inputHoraLimiteAbrirPosicao = "17:30"; //Hora limite para fazer trade às XX h ?
sinput string inputHorarioVerao = "17:30"; //Fechar Ordens e Posições às XX:XXh?
input group "■■■■■ CONFIGURAÇÃO DE MÉDIAS MÓVEIS E ATR ↓"
input int inputMMPequena = 34; //Média Móvel Pequena
input int inputMMMedia = 144; //Média Móvel Media
input int inputMMGrande = 610; //Média Móvel Grande
input int inputValorATR = 360; //Valor do ATR de 15 Minutos
input group "■■■■■ LÓGICA ↓"
input double inputTicksEntrada = 1; //Lançar Ordem a quantos ticks da máxima/mínima?
input FILTRO_MEDIAS inputFiltroDasMedias = TresMedias; //Filtro de Médias
input string ash = "----"; //----
input int inputATRMaximoDia = 90; //Faz Trade até XX% do ATR Diário.
input int inputPercentualRompimento = 50; //Percentual Rompimento (atr do 15).
input double inputMultiplicadorDoAlvo = 3.0; //Multiplicador do Alvo (ATR)
input string asd43 = "----"; //----
input INPUT_ATR_DIARIO_X_PERIODOS inputAtrDiarioHabilitado = Desabilitado_Atr_Diario; //ATR Diário Maior que XX Pontos?
input int inputFiltroAtrDiarioXPontos = 1800; //Se ativado o Filtro Acima, o filtro será de XX pontos
input int inputFiltroAtrDiarioXPeriodos = 5; //Se ativado o Filtro Acima, O ATR será de XX períodos
input string sdt4 = "----"; //----
input INPUT_ALVO_MIN_ENTRADA inputAlvoPelaMinMaxOuEntrada = Alvo_Pela_Minima_Ou_Maxima; //O Alvo será calculado Por:
input TRALING_STOP inputTralingStop = Desativa_TralingStop; //Ativar Traling Stop da MME abaixo?
input int inputMMTralingStop = 17; //Média Móvel Do Traling Stop, caso Ativado...
input string a1312 = "----"; //----
input double multiplicadorStop = 1.0; // Multiplicador Stop em % | colocar 0 na frente = 0.5 == 50%
input double breakeven_multiplicador = 2.0; //multiplicado ATR Breakeven
 //+------------------------------------------------------------------+
 //| VARIAVEIS GLOBAIS                                                |
 //+------------------------------------------------------------------+
CTrade trade;
MqlTick tick;


//--- VARIÁVEIS DO ROBÔ
double media_movel_pequena = 0;
double media_movel_media = 0;
double media_movel_grande = 0;
double media_movel_tralingstop = 0;
double atr_stop_15 = 0;
double atr_diario = 0;
double atr_diario_filtro_pts = 0;

string botao_maxima = "";
string botao_minima = "";
double maxima_do_dia = 0;
double minima_do_dia = 0;
double valor_do_stop_compra = 0;
double alvo_compra = 0;
double valor_do_stop_venda = 0;
double alvo_venda = 0;
ulong horario_executou_robo = TimeLocal();
string comprinha= "";
string vendinha = "";

//---VARIÁVEIS LOOP DE ORDENS E POSIÇÕES -----------------
bool compradoMercado = false, vendidoMercado = false, compradoPendente = false, vendidoPendente = false;
bool compradoStop = false;
bool vendidoStop = false;
ulong ticketCompradoMercado = 0, ticketVendidoMercado = 0, ticketCompradoPendente = 0, ticketVendidoPendente = 0;
ulong ticketVendidoStop = 0;
ulong ticketCompradoStop = 0;
double quantLotesPosicaoCompra = 0;
double quantLotesPosicaoVenda = 0;
double quantLotesOrdensVenda = 0;
double quantLotesOrdensCompra = 0;
double quantLotesOrdensStopCompra = 0;
double quantLotesOrdensStopVenda = 0;

uint quantPosicoesCompraExecutadasNoAtivo = 0;
uint quantPosicoesVendaExecutadasNoAtivo = 0;
uint quantPosicoesCompraExecutadasGlobal = 0;
uint quantPosicoesVendaExecutadasGlobal = 0;
uint quantOrdensCompraAbertasNoAtivo = 0;
uint quantOrdensVendaAbertasNoAtivo = 0;
uint quantOrdensCompraAbertasGlobal = 0;
uint quantOrdensVendaAbertasGlobal = 0;

double precoDeCompra = 0;
double precoDeVenda = 0;
double precoPendurouOrdemCompra = 0;
double precoPendurouOrdemVenda = 0;
double precoPendurouOrdemStopCompra = 0;
double precoPendurouOrdemStopVenda = 0;
double maiorOrdemDeCompra = 0;
double menorOrdemDeVenda = 0;
double primeiroPrecoOrdemDeVenda = 0;
bool existem_ordem_entao_nao_pode_monitorar_compra = false;
bool existem_ordem_entao_nao_pode_monitorar_venda = false;
bool se_ta_vendido_no_ask_ou_mais = false;
bool se_ta_comprado_no_bid_ou_menos = false;
bool enviou_ordem_de_compra = false;       //static
bool enviou_ordem_de_venda = false;        //static
bool ordenStopExiste = false;
string tipoOrdemAberta = "nada";
bool verificaHorarioPermitidoAbrirPosicao = false;
static bool temQueZerarVenda = false;
static bool temQueZerarCompra = false;
static int quantos_trades_fez_no_dia = 0;
bool jaDiminuiuUmaOrdemVenda = true;
bool jaDiminuiuUmaOrdemCompra = true;
double quantidadeContratos = 0; 
int minimoDeContratos = 0;
double valorFinanceiroPorTickMiniIndice = 0.2;
int valorFinanceiroPorTickIndiceCheio = 5;
double multiplicadorFinanceiroDoContrato = 0.0;
double valorStopEmReais = 0;
string NomeTipoDeContrato = " ";
double step = 0.0;
double seraQueAredonda = 0.0;
bool aredondaPeloTOPO = false;
bool aredondaPeloFUNDO = false;
bool podeTreidar = false;
MqlRates candles5[415];   //para candles do 5 min
MqlRates candlesDia[2];   //para dia anteriores
double valorPorcentagemConta1_0 = 0.010; //1.0%
double valorPorcentagemConta1_5 = 0.015; //1.5%
double valorPorcentagemConta2_0 = 0.020; //2.0%
double valorPorcentagemConta2_5 = 0.025; //1.5%
double valorPorcentagemConta3_0 = 0.03; //3.0%
double valorPorcentagemConta4_0 = 0.04; //4.0%
double valorPorcentagemConta5_0 = 0.05; //5.0%
double valorPorcentagemConta10_0 = 0.10; //10.0%
double valorPorcentagemConta15_0 = 0.15; //15.0%
double valorPorcentagemConta20_0 = 0.20; //20.0%
double valorBalancoDaConta = 0;
double RPeloBalancoDaConta = 0;
static double precoDaLinhaATRAlta= 0.0;
static double precoDaLinhaATRBaixa = 0.0;
double barra5DeOntemHIGH= 0.0;
double barra5DeOntemLOW= 0.0;
datetime primeiroCandle5Horario;
datetime chaveDiaOntem;
string roteamento_symbol = "";
double tickerBase = SymbolInfoDouble(roteamento_symbol, SYMBOL_TRADE_TICK_SIZE); //aqui calcula o valor de 1 tick do mercado/ativo
int n_ordens_enviadas = 0; // contador proteção envio massivo de ordens
bool marcou_contagem_trades = false;
double diferenca_entre_tickers = 0;
bool not_printou = false;

//--------------------------------------------------------

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
ENUM_ACCOUNT_TRADE_MODE tipoConta = (ENUM_ACCOUNT_TRADE_MODE) AccountInfoInteger(ACCOUNT_TRADE_MODE);
ENUM_ACCOUNT_MARGIN_MODE modoConta = (ENUM_ACCOUNT_MARGIN_MODE) AccountInfoInteger(ACCOUNT_MARGIN_MODE);

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
  
   if (inputModoConta == mcHEDGING) trade.SetExpertMagicNumber(VALOR_NUMERO_MAGICO);
//--- create timer
   EventSetTimer(SEGUNDOS_TIMER);
   SymbolSelect("IND$N",true);
   SymbolSelect("WIN$N",true);
   SymbolSelect(inputQualTickerAtivo,true);
   if(!VerificarInputs())
      ExpertRemove();

   ControleDeAcesso(NOME_NA_CORRETORA, NUMERO_CONTA_REAL, NUMERO_CONTA_DEMO, NUMERO_MAXIMO_CONTRATOS, DIA_DO_VENCIMENTO, MES_DO_VENCIMENTO, ANO_DO_VENCIMENTO); //chamada de função para controle de acesso ao robô!

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- destroy timer
   EventKillTimer();
   if (inputTipoContrato == IndiceCheio) SymbolSelect("IND$N",false);
   if (inputTipoContrato == MiniIndice) SymbolSelect("WIN$N",false);
   //SymbolSelect(inputQualTickerAtivo,false);
   RemoverIndicadores(); 
   
	if (inputModoConta == mcHEDGING)
  	if (GlobalVariableCheck(NOME_NUMERO_MAGICO)) GlobalVariableDel(NOME_NUMERO_MAGICO); // REMOVER O NúMERO MáGICO
   
  }

void OnTimer(void)
  {
    if (inputModoConta == mcHEDGING) trade.SetExpertMagicNumber(VALOR_NUMERO_MAGICO);
    
    ControleDeAcesso(NOME_NA_CORRETORA, NUMERO_CONTA_REAL, NUMERO_CONTA_DEMO, NUMERO_MAXIMO_CONTRATOS, DIA_DO_VENCIMENTO, MES_DO_VENCIMENTO, ANO_DO_VENCIMENTO); //chamada de função para controle de acesso ao robô!
    CriaLinhaATRMinimoDeAltaEBaixa();
    //Print("HorarioFechamentoPregaoTodasOrdens() = ", HorarioFechamentoPregaoTodasOrdens());
    //Print("HorarioFechamentoPregaoTodasOrdens2() = ", HorarioFechamentoPregaoTodasOrdens2());
    
    if (HorarioFechamentoPregaoTodasOrdens2()) {
    
    if (!not_printou) {
      Print("Chegou no horário para fechamento de ordens e posições. Caso tenha alguma ordem, será fechada!");
      not_printou = true;
    }
    FecharPosicaoAbertas();
    FecharOrdensPendentesCompraDoAtivo();  // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
    FecharOrdensPendentesVendaDoAtivo(); 
    FecharOrdensPendentesBuyStopAtivo();
    FecharOrdensPendentesSellStopAtivo();
    }
    
    if(HorarioFechamentoPregaoTodasOrdens())
    {
    FecharPosicaoAbertas();
    FecharOrdensPendentesCompraDoAtivo();  // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
    FecharOrdensPendentesVendaDoAtivo(); 
    FecharOrdensPendentesBuyStopAtivo();
    FecharOrdensPendentesSellStopAtivo();
    }
    
   if(VerificarOrdensPosicoes())
     {
      LogicaOperacional();
      FecharPosicoesContaHedge();
      modificarOrdemStopDaPosicaoDeCompra();
      modificarOrdemStopDaPosicaoDeVenda();
      AlvoDaCompra();
      AlvoDaVenda();
      TralingStop();
      ProtecaoContraLooping();
      //ProtecaoEnvioMassivoOrdens();

     }
     
   if (!HorarioPermitidoAbrirPosicao() && verificaHorarioPermitidoAbrirPosicao)
     {
      //Print("Passou do Horário de almoço!");
      verificaHorarioPermitidoAbrirPosicao = false;
      
     }
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      CriaLinhaATRMinimoDeAltaEBaixa();
      
    if (HorarioFechamentoPregaoTodasOrdens2()) {
    FecharOrdensPendentesBuyStopAtivo();
    FecharOrdensPendentesSellStopAtivo();
    FecharPosicaoAbertas();
    FecharOrdensPendentesCompraDoAtivo();  // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
    FecharOrdensPendentesVendaDoAtivo(); 

    }  
      
    if(HorarioFechamentoPregaoTodasOrdens())
    {
    FecharPosicaoAbertas();
    FecharOrdensPendentesCompraDoAtivo();  // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
    FecharOrdensPendentesVendaDoAtivo(); 
    FecharOrdensPendentesBuyStopAtivo();
    FecharOrdensPendentesSellStopAtivo();
    }
    
   if(VerificarOrdensPosicoes())
     {
      LogicaOperacional();
      FecharPosicoesContaHedge();
      modificarOrdemStopDaPosicaoDeCompra();
      modificarOrdemStopDaPosicaoDeVenda();
      AlvoDaCompra();
      AlvoDaVenda();
      TralingStop();
      ProtecaoContraLooping();
      //ProtecaoEnvioMassivoOrdens();

     }
     
   if (!HorarioPermitidoAbrirPosicao() && verificaHorarioPermitidoAbrirPosicao)
     {
      //Print("Passou do Horário de almoço!");
      verificaHorarioPermitidoAbrirPosicao = false;
      
     }

  }


//+------------------------------------------------------------------+
//| FUNÇÕES OPERACIONAIS                                             |
//+------------------------------------------------------------------+

//---
bool LogicaOperacional()
  {

   if(!SymbolInfoTick(roteamento_symbol,tick))
     {
      Print("ERRO: Dados de ticks não foram copiados corretamente");
      return (false);
     }
     
   MediasEAtr();
   
   bool filtro_do_atr_diario_em_pontos = true;
   if (inputAtrDiarioHabilitado == Habilitado_Atr_Diario && atr_diario_filtro_pts < inputFiltroAtrDiarioXPontos) {
     filtro_do_atr_diario_em_pontos = false; //marca o filtro como falso
   }
   
   
   

//bool se_saiu_leilao = SeAtivoSaiuDoLeilao();
   int desloc_primeira_barra_dia = SeAtivoSaiuDoLeilaoMarcarPrimeiraBarra(); //aqui pega o valor da função para saber quantas barras precisa deslocar para pegar max e minima da primeira barra
   static double maxima_primeira_barra = 0;
   static double minima_primeira_barra = 0;


   static bool marcou_primeira_barra = false;
   if(desloc_primeira_barra_dia == 0)
      marcou_primeira_barra = false;
   if(desloc_primeira_barra_dia != 0 && !marcou_primeira_barra)
     {
      maxima_primeira_barra = iHigh(_Symbol,PERIOD_CURRENT,desloc_primeira_barra_dia);
      minima_primeira_barra = iLow(_Symbol,PERIOD_CURRENT,desloc_primeira_barra_dia);
      
      precoDaLinhaATRAlta = maxima_primeira_barra + (MathRound(atr_stop_15*inputPercentualRompimento/tickerBase)*tickerBase)/100;
      precoDaLinhaATRBaixa = minima_primeira_barra - (MathRound(atr_stop_15*inputPercentualRompimento/tickerBase)*tickerBase)/100;
      primeiroCandle5Horario = iTime(_Symbol,PERIOD_CURRENT,desloc_primeira_barra_dia);
      
      quantos_trades_fez_no_dia = 0;
      marcou_primeira_barra = true;
     }

//-- DECLARAR DUAS VARIÁVEIS BOOLEANAS QUE CORRESPONDERAM AOS FILTROS DA MÉDIA
   static bool filtro_uma_media_venda = false;
   static bool filtro_uma_media_compra = false;
   static bool filtro_duas_medias_venda = false;
   static bool filtro_duas_medias_compra = false;
   static bool filtro_tres_medias_venda = false;
   static bool filtro_tres_medias_compra = false;
   static bool filtro_leque_tres_medias_venda = false;
   static bool filtro_leque_tres_medias_compra = false;
   double fechamento_barra_anterior = iClose(_Symbol,PERIOD_CURRENT,1);
   maxima_do_dia = iHigh(_Symbol, PERIOD_D1, 0);
   static double maxima_do_dia_compra = 0;
   minima_do_dia = iLow(_Symbol,PERIOD_D1,0);
   static double minima_do_dia_venda = 0;
   double diferenca_maxima_minima = NormalizeDouble(maxima_do_dia - minima_do_dia, _Digits);
   double percentual_atr_atingido = ((diferenca_maxima_minima*100)/atr_diario);
   bool atingiu_atr_diario = false;
   bool diferenca_tickers_deixa_fazer_trade = true;
   
   double precoAtual = NormalizeDouble(tick.last, _Digits);
   double maxima_barra_rompeu = 0; //static
   double minima_barra_rompeu = 0;
   double diferenca_maxima_barra_rompeu = 0;
   double diferenca_minima_barra_rompeu = 0;
   double percentual_barra_rompeu_maxima = 0;
   double percentual_barra_rompeu_minima = 0;
   bool ja_passou_rompimento_minima = false; //Ever | Coloquei no scopo global
   bool ja_passou_rompimento_maxima = false; //static
   //bool enviou_ordem_de_compra = false;       //static
   //bool enviou_ordem_de_venda = false; //static

   if(desloc_primeira_barra_dia == 0)
     {

      maxima_primeira_barra = 0;
      minima_primeira_barra = 0;
      maxima_barra_rompeu = 0;
      minima_barra_rompeu = 0;
      diferenca_maxima_barra_rompeu = 0;
      diferenca_minima_barra_rompeu = 0;
      percentual_barra_rompeu_maxima = 0;
      percentual_barra_rompeu_minima = 0;
      ja_passou_rompimento_minima = false;
      ja_passou_rompimento_maxima = false;
      enviou_ordem_de_compra = false;
      enviou_ordem_de_venda = false;
      quantos_trades_fez_no_dia = 0;
      marcou_contagem_trades = false;
      maxima_do_dia_compra = 0;
      minima_do_dia_venda = 0;

     }

   if(NovoDia())
     {
      enviou_ordem_de_compra = false;
      enviou_ordem_de_venda = false;
      quantos_trades_fez_no_dia = 0;
      not_printou = false;
      
     }

//CÁLCULO SE ATINGIU ATR DIARIO
   if(percentual_atr_atingido >= inputATRMaximoDia)
      atingiu_atr_diario = true;
      
//SE ATINGIU O ATR DIARIO E TIVER ORDEM START(STOP) ABERTA, ENTAO CANCELA ESSAS ORDENS
   if (atingiu_atr_diario && VerificarOrdensPosicoes() && !compradoMercado && !vendidoMercado) { //se atingiu ATR do DIA e nao tenho posicao aberta
     if (ticketCompradoStop != 0) { //se eu tenho uma ordem stop/start de compra aberta
        FecharOrdensPendentesBuyStopAtivo();  //entao deleto essa ordem
     } else if (ticketVendidoStop != 0) { //se eu tenho uma ordem stop/start de venda aberta
        FecharOrdensPendentesSellStopAtivo(); //entao deleto essa ordem
     }
   } 

//CÁLCULO PERCENTUAL DO ATR15 QUE ROMPEU A MÍNIMA/MÁXIMA DA PRIMEIRA BARRA DO DIA

   if(HorarioPermitidoAbrirPosicao() && !ja_passou_rompimento_minima && fechamento_barra_anterior < minima_primeira_barra)
     {
      maxima_barra_rompeu = iHigh(_Symbol, PERIOD_CURRENT, 1);
      minima_barra_rompeu = iLow(_Symbol, PERIOD_CURRENT, 1);
      double fechamento_barra_rompeu = iClose(_Symbol, PERIOD_CURRENT, 1);
      diferenca_minima_barra_rompeu = NormalizeDouble(minima_primeira_barra - fechamento_barra_rompeu, _Digits);
      percentual_barra_rompeu_minima = ((diferenca_minima_barra_rompeu*100)/atr_stop_15);
      ja_passou_rompimento_minima = true;

     }

   if(HorarioPermitidoAbrirPosicao() && !ja_passou_rompimento_maxima && (maxima_primeira_barra > 0) && fechamento_barra_anterior > maxima_primeira_barra)
     {
      maxima_barra_rompeu = iHigh(_Symbol, PERIOD_CURRENT, 1);
      minima_barra_rompeu = iLow(_Symbol, PERIOD_CURRENT, 1);
      double fechamento_barra_rompeu = iClose(_Symbol, PERIOD_CURRENT, 1);
      diferenca_maxima_barra_rompeu = NormalizeDouble(fechamento_barra_rompeu - maxima_primeira_barra, _Digits);
      percentual_barra_rompeu_maxima = ((diferenca_maxima_barra_rompeu*100)/atr_stop_15);
      ja_passou_rompimento_maxima = true;
      //---
      verificaHorarioPermitidoAbrirPosicao = true; //Ever | Se o pregão ja começou ativa chave pra zerar operações apenas 1 vez depois que sair do horário de almoço
     }

//LÓGICA PIVO COMPRA
   bool valida_pivo_compra = false;
  //if(ja_passou_rompimento_maxima && !compradoMercado)
   if(!compradoMercado) {
      valida_pivo_compra = true;
     }

//LÓGICA PIVO VENDA
   bool valida_pivo_venda = false;
   //if(ja_passou_rompimento_minima && !vendidoMercado)
   if(!vendidoMercado) {
      valida_pivo_venda = true;
     } 
     
//LÓGICA NOVA PARA NAO DEIXAR O ATIVO FAZER TRADE COM SPREAD GRANDE

   if (HorarioNoveECinco() && (inputTipoContrato == IndiceCheio || Dolar_Cheio)) {
     double minima_do_dia_do_ticker = iLow(inputQualTickerAtivo,PERIOD_D1,0);
     double maxima_do_dia_do_ticker = iHigh(inputQualTickerAtivo,PERIOD_D1,0);
     diferenca_entre_tickers = MathAbs(minima_do_dia-minima_do_dia_do_ticker);
     if (diferenca_entre_tickers >= (tickerBase*40)) diferenca_tickers_deixa_fazer_trade = false;
   } 

//LÓGICA DA VENDA PARA UMA MEDIAS    
                    //Ever | Filtro uma media
   if(fechamento_barra_anterior < media_movel_pequena) 
     {
      filtro_uma_media_venda = true;
     }
   else
     {
      filtro_uma_media_venda = false;
     }

//LÓGICA DA COMPRA PARA UMA MEDIAS                       //Ever | Filtro uma media
   if(fechamento_barra_anterior > media_movel_pequena) 
     {
      filtro_uma_media_compra = true;
     }
   else
     {
      filtro_uma_media_compra = false;
     }

//LÓGICA DA VENDA PARA DUAS MEDIAS
   if((fechamento_barra_anterior < media_movel_pequena) && ((fechamento_barra_anterior < media_movel_media) || (fechamento_barra_anterior < media_movel_grande)))
     {
      filtro_duas_medias_venda = true;
     }
   else
     {
      filtro_duas_medias_venda = false;
     }

//LÓGICA DA COMPRA PARA DUAS MEDIAS
   if((fechamento_barra_anterior > media_movel_pequena) && ((fechamento_barra_anterior > media_movel_media) || (fechamento_barra_anterior > media_movel_grande)))
     {
      filtro_duas_medias_compra = true;
     }
   else
     {
      filtro_duas_medias_compra = false;
     }

//LÓGICA DA VENDA PARA TRES MEDIAS
   if((fechamento_barra_anterior < media_movel_pequena) && (fechamento_barra_anterior < media_movel_media) && (fechamento_barra_anterior < media_movel_grande))
     {
      filtro_tres_medias_venda = true;
     }
   else
     {
      filtro_tres_medias_venda = false;
     }

//LÓGICA DA COMPRA PARA TRES MEDIAS
   if((fechamento_barra_anterior > media_movel_pequena) && (fechamento_barra_anterior > media_movel_media) && (fechamento_barra_anterior > media_movel_grande))
     {
      filtro_tres_medias_compra = true;
     }
   else
     {
      filtro_tres_medias_compra = false;
     }

//LÓGICA DA VENDA PARA LEQUE DE TRES MEDIAS
   if((fechamento_barra_anterior < media_movel_pequena) && (media_movel_pequena < media_movel_media) && (media_movel_media < media_movel_grande))
     {
      filtro_leque_tres_medias_venda = true;
     }
   else
     {
      filtro_leque_tres_medias_venda = false;
     }

//LÓGICA DA COMPRA PARA LEQUE DE TRES MEDIAS
   if((fechamento_barra_anterior > media_movel_pequena) && (media_movel_pequena > media_movel_media) && (media_movel_media > media_movel_grande))
     {
      filtro_leque_tres_medias_compra = true;
     }
   else
     {
      filtro_leque_tres_medias_compra = false;
     }    
     
   bool podeComprar = false;
   bool podeVender = false;
   bool podeComprarPivo = false;
   bool podeVenderPivo = false;

   if(inputFiltroDasMedias == DuasMedias)
     {

      podeComprar =
         (HorarioPermitidoAbrirPosicao()) &&
         (filtro_duas_medias_compra) &&
         (!atingiu_atr_diario) &&
         (percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
         (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
         (diferenca_tickers_deixa_fazer_trade) &&
         (filtro_do_atr_diario_em_pontos) &&
         //(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
         (!enviou_ordem_de_compra);

      podeComprarPivo =
         (HorarioPermitidoAbrirPosicao()) &&
         (filtro_duas_medias_compra) &&
         (!atingiu_atr_diario) &&
         (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
         (diferenca_tickers_deixa_fazer_trade) &&
         (filtro_do_atr_diario_em_pontos) &&
         (enviou_ordem_de_compra) &&
         (tick.last >= ((maxima_do_dia)-(tickerBase*15))) && // tire menos 50 = ((maxima_do_dia+5)-50))
         (valida_pivo_compra);

      podeVender =
         (HorarioPermitidoAbrirPosicao()) &&
         (filtro_duas_medias_venda) &&
         (!atingiu_atr_diario) &&
         (percentual_barra_rompeu_minima >= inputPercentualRompimento) &&
         (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
         (diferenca_tickers_deixa_fazer_trade) &&
         (filtro_do_atr_diario_em_pontos) &&
         //(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
         (!enviou_ordem_de_venda);

      podeVenderPivo =
         (HorarioPermitidoAbrirPosicao()) &&
         (filtro_duas_medias_venda) &&
         (!atingiu_atr_diario) &&
         (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
         (diferenca_tickers_deixa_fazer_trade) &&
         (filtro_do_atr_diario_em_pontos) &&
         (enviou_ordem_de_venda) &&
         (tick.last <= ((minima_do_dia)+(tickerBase*15))) && // ((minima_do_dia-5)+50))
         (valida_pivo_venda);
     }
     
   else
   
      if(inputFiltroDasMedias == TresMedias)
        {

         podeComprar =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_tres_medias_compra) &&
            (!atingiu_atr_diario) &&
            (percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (filtro_do_atr_diario_em_pontos) &&
            //(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
            (!enviou_ordem_de_compra);

         podeComprarPivo =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_tres_medias_compra) &&
            (!atingiu_atr_diario) &&
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (enviou_ordem_de_compra) &&
            (filtro_do_atr_diario_em_pontos) &&
            (tick.last > ((maxima_do_dia)-(tickerBase*15))) && // ((maxima_do_dia+5)-50)) &&
            (valida_pivo_compra);

         podeVender =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_tres_medias_venda) &&
            (!atingiu_atr_diario) &&
            (percentual_barra_rompeu_minima >= inputPercentualRompimento) && //Mudei de > para menos
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (filtro_do_atr_diario_em_pontos) &&
            //(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
            (!enviou_ordem_de_venda);

         podeVenderPivo =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_tres_medias_venda) &&
            (!atingiu_atr_diario) &&
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (enviou_ordem_de_venda) &&
            (filtro_do_atr_diario_em_pontos) &&
            (tick.last < ((minima_do_dia)+(tickerBase*15))) && // ((minima_do_dia-5)+50))
            (valida_pivo_venda);

        }
        else
        if(inputFiltroDasMedias == LequeTresMedias)
        {

         podeComprar =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_leque_tres_medias_compra) &&
            (!atingiu_atr_diario) &&
            (percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (filtro_do_atr_diario_em_pontos) &&
            //(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
            (!enviou_ordem_de_compra);

         podeComprarPivo =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_leque_tres_medias_compra) &&
            (!atingiu_atr_diario) &&
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (enviou_ordem_de_compra) &&
            (filtro_do_atr_diario_em_pontos) &&
            (tick.last > ((maxima_do_dia)-(tickerBase*15))) && // ((maxima_do_dia+5)-50)) &&
            (valida_pivo_compra);

         podeVender =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_leque_tres_medias_venda) &&
            (!atingiu_atr_diario) &&
            (percentual_barra_rompeu_minima >= inputPercentualRompimento) && //Mudei de > para menos
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (filtro_do_atr_diario_em_pontos) &&
            //(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
            (!enviou_ordem_de_venda);

         podeVenderPivo =
            (HorarioPermitidoAbrirPosicao()) &&
            (filtro_leque_tres_medias_venda) &&
            (!atingiu_atr_diario) &&
            (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
            (diferenca_tickers_deixa_fazer_trade) &&
            (enviou_ordem_de_venda) &&
            (filtro_do_atr_diario_em_pontos) &&
            (tick.last < ((minima_do_dia)+(tickerBase*15))) && // ((minima_do_dia-5)+50))
            (valida_pivo_venda);
        }
        
      else
         if(inputFiltroDasMedias == SemMedias)
           {

            podeComprar =
               (HorarioPermitidoAbrirPosicao()) &&
               (!atingiu_atr_diario) &&
               (percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
               (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
               (diferenca_tickers_deixa_fazer_trade) &&
               (filtro_do_atr_diario_em_pontos) &&
               //(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
               (!enviou_ordem_de_compra);

            podeComprarPivo =
               (HorarioPermitidoAbrirPosicao()) &&
               (!atingiu_atr_diario) &&
               (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
               (diferenca_tickers_deixa_fazer_trade) &&
               (enviou_ordem_de_compra) &&
               (filtro_do_atr_diario_em_pontos) &&
               (tick.last >= ((maxima_do_dia+tickerBase)-(tickerBase*15))) &&
               (valida_pivo_compra);

            podeVender =
               (HorarioPermitidoAbrirPosicao()) &&
               (!atingiu_atr_diario) &&
               (percentual_barra_rompeu_minima >= inputPercentualRompimento) &&
               (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
               (diferenca_tickers_deixa_fazer_trade) &&
               (filtro_do_atr_diario_em_pontos) &&
               //(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
               (!enviou_ordem_de_venda);

            podeVenderPivo =
               (HorarioPermitidoAbrirPosicao()) &&
               (!atingiu_atr_diario) &&
               (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
               (diferenca_tickers_deixa_fazer_trade) &&
               (enviou_ordem_de_venda) &&
               (filtro_do_atr_diario_em_pontos) &&
               (tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
               (valida_pivo_venda);
           }
           
           else
              if(inputFiltroDasMedias == UmaMedia)
                 {
            
                  podeComprar =
                     (HorarioPermitidoAbrirPosicao()) &&
                     (filtro_uma_media_compra) &&
                     (!atingiu_atr_diario) &&
                     (percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
                     (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
                     (diferenca_tickers_deixa_fazer_trade) &&
                     (filtro_do_atr_diario_em_pontos) &&
                     //(tick.last >= ((maxima_do_dia+tickerBase)-(tickerBase*15))) &&
                     (!enviou_ordem_de_compra);
            
                  podeComprarPivo =
                     (HorarioPermitidoAbrirPosicao()) &&
                     (filtro_uma_media_compra) &&
                     (!atingiu_atr_diario) &&
                     (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
                     (diferenca_tickers_deixa_fazer_trade) &&
                     (enviou_ordem_de_compra) &&
                     (filtro_do_atr_diario_em_pontos) &&
                     (tick.last >= ((maxima_do_dia+tickerBase)-(tickerBase*15))) &&
                     (valida_pivo_compra);
            
                  podeVender =
                     (HorarioPermitidoAbrirPosicao()) &&
                     (filtro_uma_media_venda) &&
                     (!atingiu_atr_diario) &&
                     (percentual_barra_rompeu_minima >= inputPercentualRompimento) &&
                     (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
                     (diferenca_tickers_deixa_fazer_trade) &&
                     (filtro_do_atr_diario_em_pontos) &&
                     //(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
                     (!enviou_ordem_de_venda);
            
                  podeVenderPivo =
                     (HorarioPermitidoAbrirPosicao()) &&
                     (filtro_uma_media_venda) &&
                     (!atingiu_atr_diario) &&
                     (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
                     (diferenca_tickers_deixa_fazer_trade) &&
                     (enviou_ordem_de_venda) &&
                     (filtro_do_atr_diario_em_pontos) &&
                     (tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
                     (valida_pivo_venda);          
           
                 }

//+------------------------------------------------------------------+
//|  roteamento da compra                                            |
//+------------------------------------------------------------------+
  if(inputPorcentagemConta == PorcentagemConta)
    {
     QuantidadeContratosPorPorcentagemDeConta();
    }
  if(inputPorcentagemConta == RFixo)
    {
     QuantidadeContratosDoR();
    }
  if(inputPorcentagemConta == LoteFixo)
    {
     quantidadeContratos = quantidadeDeContratosFixo;
    }

  //---aqui faz a contagem dos trades no dia e deleta a ordem
  if ((compradoMercado || vendidoMercado) && !marcou_contagem_trades) {
    quantos_trades_fez_no_dia++;
    marcou_contagem_trades = true;  
  }
  if (marcou_contagem_trades && (!compradoMercado && !vendidoMercado)) marcou_contagem_trades = false;
  //--------
  //---aqui deleta a ordem stop de compra caso tenha enviado e voltou 100 pontos
  if (compradoStop && vendidoMercado) {
    Print("A ordem Stop de Compra que estava pendurada para tomar posição foi fechada, pois tomou posição de venda");
    FecharOrdensPendentesBuyStopAtivo();
    enviou_ordem_de_compra = false;
    tipoOrdemAberta = "nada";
    ordenStopExiste = false;
  } else if (vendidoStop && compradoMercado) {
    Print("A ordem Stop de Venda que estava pendurada para tomar posição foi fechada, pois tomou posição de compra");
    FecharOrdensPendentesSellStopAtivo();
    enviou_ordem_de_venda = false;
    tipoOrdemAberta = "nada";
    ordenStopExiste = false;
  }
  //--------
  
  //--------
    
   if((podeComprar || podeComprarPivo) && !compradoMercado && !vendidoMercado && !compradoStop && (quantLotesPosicaoCompra < quantidadeContratos) && podeTreidar)
     {
      ordenStopExiste = true;  // Ever | Chave pra validar loop de deletar ordens pendentes longe do preço e não entrar em loop de deletar ordens
      tipoOrdemAberta = "compra";
      bool ok = false;
      double adicionar_ticks = tickerBase*inputTicksEntrada;
      valor_do_stop_compra = ((maxima_do_dia+adicionar_ticks) - (MathRound(atr_stop_15*multiplicadorStop/tickerBase)*tickerBase));
      //alvo_compra = (maxima_do_dia+tickerBase) + (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase);
      

      ok = trade.BuyStop(quantidadeContratos, maxima_do_dia+adicionar_ticks, roteamento_symbol, valor_do_stop_compra, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO);
      enviou_ordem_de_compra = true;
      jaDiminuiuUmaOrdemCompra = false; // chave para validar diminuição do contador de trades apenas 1 vez por ordem, quando remover ordem stop no on tick
      n_ordens_enviadas++; //proteção envio massivo de ordens
      if(ok)
        {
         if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
           {
            Print("Ordem de COMPRA BuyStop enviada com sucesso!");
           }
         else
           {
            Print("ERRO1: COMPRA, BuyStop nao foi enviada");
           }
        }
      else if (VerificarOrdensPosicoes())
        {
         if (VerificarOrdensPosicoes() && !compradoMercado) {
           FecharOrdensPendentesBuyStopAtivo();
           ok = trade.Buy(quantidadeContratos, roteamento_symbol, maxima_do_dia+tickerBase, valor_do_stop_compra, 0, NOME_ROBO);
           Print("O preço pulou o gatilho da compra, então o robô COMPROU A MERCADO");
           enviou_ordem_de_compra = true;
           jaDiminuiuUmaOrdemCompra = false;
           n_ordens_enviadas++;
         }
        }
        
//        //CRIA LINHA BREAKEVEN COMPRA
//        datetime barraDaCompra = iTime(_Symbol,PERIOD_CURRENT,0);
//        ObjectCreate(
//                0,                            // ID de gráfico
//                "comprinha",        // Nome da linha
//                OBJ_HLINE,                    // Tipo da linha
//                0,                            // Sub Window
//                barraDaCompra,       // Datetime do objeto         
//                maxima_do_dia+adicionar_ticks                 // Preço
//                );   
//        ObjectSetInteger(0,"comprinha",OBJPROP_STYLE,STYLE_DOT);
//        ObjectSetInteger(0,"comprinha",OBJPROP_COLOR,clrRed);
//        
//        
//        
//        
//        
//        if (precoAtual >= maxima_do_dia+adicionar_ticks) { 
//         ok = trade.Buy(quantidadeContratos, roteamento_symbol, 0, valor_do_stop_compra, 0, NOME_ROBO);
//         Print("O robô COMPROU A MERCADO - Preço que tentou comprar = " + DoubleToString(maxima_do_dia+adicionar_ticks, _Digits));
//         enviou_ordem_de_compra = true;
//         jaDiminuiuUmaOrdemCompra = false;
//         n_ordens_enviadas++;
//        }
        
        
     } else {
     
      //deletar objeto linha horizontal
      //if( ObjectFind(0,comprinha)>=0 ) ObjectDelete(0,comprinha);
     
     }

//+------------------------------------------------------------------+
//|  roteamento da venda                                             |
//+------------------------------------------------------------------+

   if((podeVender || podeVenderPivo) && !compradoMercado && !vendidoMercado && !vendidoStop && (quantLotesPosicaoVenda < quantidadeContratos) && podeTreidar)
     {
      ordenStopExiste = true;  // Ever | Chave pra validar loop de deletar ordens pendentes longe do preço e não entrar em loop de deletar ordens
      tipoOrdemAberta = "venda";
      bool ok = false;
      double adicionar_ticks = tickerBase*inputTicksEntrada;
      valor_do_stop_venda = ((minima_do_dia-adicionar_ticks) + (MathRound(atr_stop_15*multiplicadorStop/tickerBase)*tickerBase));
      //alvo_venda = (minima_do_dia-tickerBase) - (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase);
         
      ok = trade.SellStop(quantidadeContratos, minima_do_dia-adicionar_ticks, roteamento_symbol, valor_do_stop_venda, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO); 
      enviou_ordem_de_venda = true;
      jaDiminuiuUmaOrdemVenda = false; // chave para validar diminuição do contador de trades apenas 1 vez por ordem, quando remover ordem stop no on tick
      n_ordens_enviadas++; //proteção envio massivo de ordens
      if(ok)
        {
         if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
           {
            Print("Ordem de VENDA SellStop enviada com sucesso!");
           }
         else
           {
            Print("ERRO1: VENDA, SellStop nao foi enviada");
           }
        }
      else if (VerificarOrdensPosicoes())
        {
           if (VerificarOrdensPosicoes() && !vendidoMercado) {
             FecharOrdensPendentesSellStopAtivo();
             ok = trade.Sell(quantidadeContratos, roteamento_symbol, minima_do_dia-tickerBase, valor_do_stop_venda, 0, NOME_ROBO);
             Print("O preço pulou o gatilho da venda, então o robô VENDEU A MERCADO");
             enviou_ordem_de_venda = true;
             jaDiminuiuUmaOrdemVenda = false;
             n_ordens_enviadas++;
           }
        }
      
      
//        //CRIA LINHA BREAKEVEN VENDA
//        datetime barraDaVenda = iTime(_Symbol,PERIOD_CURRENT,0);
//        ObjectCreate(
//                0,                            // ID de gráfico
//                "vendinha",        // Nome da linha
//                OBJ_HLINE,                    // Tipo da linha
//                0,                            // Sub Window
//                barraDaVenda,       // Datetime do objeto         
//                minima_do_dia-adicionar_ticks                 // Preço
//                );   
//        ObjectSetInteger(0,"vendinha",OBJPROP_STYLE,STYLE_DOT);
//        ObjectSetInteger(0,"vendinha",OBJPROP_COLOR,clrRed);
//      
//      
//        if (precoAtual <= minima_do_dia-adicionar_ticks) {
//           ok = trade.Sell(quantidadeContratos, roteamento_symbol, 0, valor_do_stop_venda, 0, NOME_ROBO);
//           Print("O robô VENDEU A MERCADO - Preço que tentou vender = " + DoubleToString(minima_do_dia-adicionar_ticks, _Digits));
//           enviou_ordem_de_venda = true;
//           jaDiminuiuUmaOrdemVenda = false;
//           n_ordens_enviadas++;
//        }
        
      
     } else {
     
      //deletar objeto linha horizontal
      //if( ObjectFind(0,vendinha)>=0 ) ObjectDelete(0,vendinha);
     
     }
     
   if (inputMostrarComentarios == Sim_MostrarOsComentarios) {
   string string_filtro_atr_diario = "";
   if (inputAtrDiarioHabilitado == Habilitado_Atr_Diario) string_filtro_atr_diario = "\n Filtro Atr Diário em "+ (string)inputFiltroAtrDiarioXPontos + "pts, o ATR Diário está marcando " + DoubleToString(atr_diario_filtro_pts, _Digits) + "pts. Pode fazer trade? = " + (string)filtro_do_atr_diario_em_pontos;
   Comment("marcou_primeira_barra = " + (string)marcou_primeira_barra,
           "\nquantos_trades_fez_no_dia = (" + (string)quantos_trades_fez_no_dia + "/" + (string)inputMaximoTradesNoDia + ")" + "   |   marcou_contagem_trades = " + (string)marcou_contagem_trades,
           "\ndesloc_primeira_barra_dia = " + (string)desloc_primeira_barra_dia,
           "\nmedia_movel_pequena (" + (string)inputMMPequena + ") = " + DoubleToString(media_movel_pequena, _Digits),
           "\nmedia_movel_media (" + (string)inputMMMedia + ") = " + DoubleToString(media_movel_media, _Digits),
           "\nmedia_movel_grande (" + (string)inputMMGrande + ") = " + DoubleToString(media_movel_grande, _Digits),
           "\natr_stop_15 = " + DoubleToString(atr_stop_15, _Digits),
           "\natr_diario = " + DoubleToString(atr_diario, _Digits),
           "\nmaxima_primeira_barra = " + DoubleToString(maxima_primeira_barra, _Digits),
           "\nminima_primeira_barra = " + DoubleToString(minima_primeira_barra, _Digits),
           "\n",
           "\nfechamento_barra_anterior = " + DoubleToString(fechamento_barra_anterior, _Digits),
           "\nmaxima_do_dia = " + DoubleToString(maxima_do_dia, _Digits),
           "\nminima_do_dia = " + DoubleToString(minima_do_dia, _Digits),
           "\ndiferenca_maxima_minima = " + DoubleToString(diferenca_maxima_minima, _Digits),
           "\npercentual_atr_atingido = " + DoubleToString(percentual_atr_atingido, _Digits) + "%  /  " + (string)atingiu_atr_diario,
           "\n",
           "\nACCOUNT_BALANCE =  " + DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE), _Digits),
           "\nR Pelo Balanco Da Conta =  "+ (string)RPeloBalancoDaConta,
           "\nmaxima_barra_rompeu = " + DoubleToString(maxima_barra_rompeu, _Digits),
           "\ndiferenca_maxima_barra_rompeu = " + DoubleToString(diferenca_maxima_barra_rompeu, _Digits),
           "\npercentual_barra_rompeu_maxima = " + DoubleToString(percentual_barra_rompeu_maxima, _Digits),
           "\nminima_barra_rompeu = " + DoubleToString(minima_barra_rompeu, _Digits),
           "\ndiferenca_minima_barra_rompeu = " + DoubleToString(diferenca_minima_barra_rompeu, _Digits),
           "\npercentual_barra_rompeu_minima = " + DoubleToString(percentual_barra_rompeu_minima, _Digits),
           "\n ja_passou_rompimento_maxima = ", ja_passou_rompimento_maxima,
           "\n ja_passou_rompimento_minima = ", ja_passou_rompimento_minima,
           "\nMathRound(atr_stop_15/5)*5) = " + (string)atr_stop_15,
           //"\nPossível Entrada Compra= " + DoubleToString((maxima_do_dia+tickerBase), _Digits),
           //"\nPossível Entrada Venda= " + DoubleToString((minima_do_dia-tickerBase), _Digits),
           "\n ------ " + 
           "\nDiferença de ticks = " + DoubleToString(diferenca_entre_tickers, _Digits) + "pts  /  " + (string)diferenca_tickers_deixa_fazer_trade + " = deixa fazer trade" +  
           "\nprecoDeCompra = " + DoubleToString(precoDeCompra, _Digits),
           "\nprecoDeVenda = " + DoubleToString(precoDeVenda, _Digits),
           //"\nprecoDeVenda + 5 = " + DoubleToString(precoDeVenda+(tickerBase*3), _Digits),
           //"\nprecoDeVenda + 5.0 = " + DoubleToString(precoDeVenda+(tickerBase*3), _Digits),
           //"\nstop = " + DoubleToString((maxima_do_dia+1) - atr_stop_15, _Digits),
           "\nBK Compra = " + DoubleToString((precoDeCompra) + (MathRound(atr_stop_15*breakeven_multiplicador/tickerBase)*tickerBase),_Digits),
           "\nBK Venda = " + DoubleToString((precoDeVenda) - (MathRound(breakeven_multiplicador*atr_stop_15/tickerBase)*tickerBase),_Digits), 
           "\nAlvo Compra = " + string(MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase) + " pts  -> " +  DoubleToString(alvo_compra, _Digits),
           "\nAlvo Venda = " + string(MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase) + " pts  -> " + DoubleToString(alvo_venda, _Digits),
           "\n ------ " + 
           "\nenviou_ordem_de_compra = " + (string)enviou_ordem_de_compra,
           "\nenviou_ordem_de_venda = " + (string)enviou_ordem_de_venda,
           string_filtro_atr_diario + 
          // "\nquantos_trades_fez_no_dia = " + (string)quantos_trades_fez_no_dia,
           "\n",
           "\n1 HorarioPermitidoAbrirPosicao= " + (string)HorarioPermitidoAbrirPosicao(),
           "\n2 Filtro_tres_medias_compra= " + (string)(filtro_tres_medias_compra),
           "\n3 !Atingiu_atr_diario= " + (string)!atingiu_atr_diario,
           "\n4 Percentual_barra_rompeu_maxima = " + (string)(percentual_barra_rompeu_maxima >= inputPercentualRompimento),
           "\n5 Enviou Ordem de Compra = " + (string)enviou_ordem_de_compra,
           "\n6 Enviou Ordem de Venda= " + (string)enviou_ordem_de_venda,
           "\n7 CompradoMercado= " + (string)compradoMercado,
           "\n8 VendidoMercado= " + (string)vendidoMercado,
           "\n" +
           "\nquantidadeContratos = " + (string)quantidadeContratos +
           "\n1 HorarioPermitidoAbrirPosicao= " + (string)HorarioPermitidoAbrirPosicao() +
           "\n2 filtro_tres_medias_venda= " + (string)(filtro_tres_medias_venda) +
           "\n3 !Atingiu_atr_diario= " + (string)!atingiu_atr_diario +
           "\n4 percentual_barra_rompeu_minima = " + (string)(percentual_barra_rompeu_minima >= inputPercentualRompimento) + "   VALOR percentual_barra_rompeu_minima  =  " + DoubleToString(percentual_barra_rompeu_minima, _Digits) +
           "\n5 VALOR_NUMERO_MAGICO =" + (string)VALOR_NUMERO_MAGICO +
           "\n6 !Enviou Ordem de Venda= " + (string)!enviou_ordem_de_venda +
           "\n7 !CompradoMercado= " + (string)!compradoMercado +
           "\n8 !VendidoMercado= " + (string)!vendidoMercado +
           "\n9 !vendidoStop " + (string)!vendidoStop +
           "\n10 (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) = " + (string)(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) +
           "\n11 (quantLotesPosicaoVenda < quantidadeContratos) = " + (string)(quantLotesPosicaoVenda < quantidadeContratos) +
           "\n12 podeTreidar = " + (string)podeTreidar
           
           


          );
   }

   return (true);
  }



//---
bool modificarOrdemStopDaPosicaoDeCompra()
  {
   double se_atingir_bk_compra = ((precoDeCompra) + (MathRound(breakeven_multiplicador*atr_stop_15/tickerBase)*tickerBase));
   double precoNovoStopDaPosicaoDeCompra = (precoDeCompra-(tickerBase*2));
   static bool passou_pela_logica_compra = false;   // static
   if (!compradoMercado) passou_pela_logica_compra = false;
 
  //CRIA LINHA BREAKEVEN COMPRA
   datetime barraDoBreakevenCompra = iTime(_Symbol,PERIOD_CURRENT,0);
   ObjectCreate(
                0,                            // ID de gráfico
                "breakevenlineCompra1",        // Nome da linha
                OBJ_HLINE,                    // Tipo da linha
                0,                            // Sub Window
                barraDoBreakevenCompra,       // Datetime do objeto         
                se_atingir_bk_compra                 // Preço
                );
                
   ObjectSetInteger(0,"breakevenlineCompra1",OBJPROP_STYLE,STYLE_DOT);
   ObjectSetInteger(0,"breakevenlineCompra1",OBJPROP_COLOR,clrBlue);
   
  //LÓGICA ORDEM STOP BREAKEVEN

   if (precoDeCompra != 0) 
     {
     if((tick.last >= se_atingir_bk_compra) && !passou_pela_logica_compra)
       {
        passou_pela_logica_compra = true;
  
        int positionsTotal = PositionsTotal();
  
        for(int i=0; i < positionsTotal && !IsStopped(); i++)
          {
           ulong posTicket = PositionGetTicket(i);
  
           if(PositionSelectByTicket(posTicket))
             {
              ulong posMagic = PositionGetInteger(POSITION_MAGIC);
  
              string posSymbol = PositionGetString(POSITION_SYMBOL);
  
              ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
  
              if(inputModoConta == mcNETTING)
                {
                 if(posSymbol == roteamento_symbol)
                   {
                    if(posType == POSITION_TYPE_BUY)
                      {
                       bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeCompra, 0);
                       if(ok)
                         {
                          if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                            {
                             Print("AQUIIIII - Ordem de STOP da Posição de Compra foi modificada para o BreakEven COMPRA");
                            }
                          else
                            {
                             Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
  
                             return(false);
                            }
                         }
                       else
                         {
                          Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
                          return(false);
                         }
                      }
                   }
                }
              else
                {
                 if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
                   {
                    if(posType == POSITION_TYPE_BUY )  //Talvez adicionar ordem BUY STOP
                      {
                       bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeCompra, 0);
                       if(ok)
                         {
                          if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                            {
                             //modificouOrdemStop = 1;
                             Print("Ordem de STOP da Posição de Compra foi modificada para o BreakEven");
                            }
                          else
                            {
                             Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
  
                             return(false);
                            }
                         }
                       else
                         {
                          Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
                          return(false);
                         }
                      }
                   }
                }
             }
          }
       }
    }
   
   return true;
  }

//---
bool modificarOrdemStopDaPosicaoDeVenda()
  {
   
   double se_atingir_bk = ((precoDeVenda) - (MathRound(breakeven_multiplicador*atr_stop_15/tickerBase)*tickerBase));
   double precoNovoStopDaPosicaoDeVenda = (precoDeVenda+(tickerBase*2));
   static bool passou_pela_logica = false;
   if (!vendidoMercado) passou_pela_logica = false;

  //CRIA LINHA BREAKEVEN COMPRA
   datetime barraDoBreakevenVenda = iTime(_Symbol,PERIOD_CURRENT,0);
  
   ObjectCreate(
                0,                            // ID de gráfico
                "breakevenlineVenda1",        // Nome da linha
                OBJ_HLINE,                    // Tipo da linha
                0,                            // Sub Window
                barraDoBreakevenVenda,        // Datetime do objeto         
                se_atingir_bk                 // Preço
                );
                
   ObjectSetInteger(0,"breakevenlineVenda1",OBJPROP_STYLE,STYLE_DOT);
   ObjectSetInteger(0,"breakevenlineVenda1",OBJPROP_COLOR,clrBlue);
 
  //LÓGICA ORDEM STOP BREAKEVEN
   if (precoDeVenda != 0) { 
     if((tick.last <= se_atingir_bk) && !passou_pela_logica)
       {
        passou_pela_logica = true;
  
        int positionsTotal = PositionsTotal();
  
        for(int i=0; i < positionsTotal && !IsStopped(); i++)
          {
          
           ulong posTicket = PositionGetTicket(i);
  
           if(PositionSelectByTicket(posTicket))
             {
              ulong posMagic = PositionGetInteger(POSITION_MAGIC);
  
              string posSymbol = PositionGetString(POSITION_SYMBOL);
  
              ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
  
              if(inputModoConta == mcNETTING)
                {
                 if(posSymbol == roteamento_symbol)
                   {
                    if(posType == POSITION_TYPE_SELL ) //Talvez adicionar ordem SELL STOP
                      {
                       bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeVenda, 0);
                       if(ok)
                         {
                          if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                            {
                             //modificouOrdemStop = 1;
                             Print("Ordem de STOP da Posição de Venda foi modificada para o BreakEven");
                            }
                          else
                            {
                             Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
  
                             return(false);
                            }
                         }
                       else
                         {
                          Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
                          return(false);
                         }
                      }
                   }
                }
              else
                {
                 if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
                   {
                    if(posType == POSITION_TYPE_SELL)
                      {
                       bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeVenda, 0);
                       if(ok)
                         {
                          if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                            {
                             //modificouOrdemStop = 1;
                             Print("Ordem de STOP da Posição de Venda foi modificada para o BreakEven");
                            }
                          else
                            {
                             Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
  
                             return(false);
                            }
                         }
                       else
                         {
                          Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
                          return(false);
                         }
                      }
                   }
                }
             }
          }
       }
     }

   return true;
  }

//---
//bool FecharPosicoesContaHedge() {
//
//  //+----------------------------------------------------------------+
//  //| SE TIVER UMA COMPRA E VENDA POSICIONADAS, FECHA UMA PELA OUTRA |
//  //+----------------------------------------------------------------+
//  if (inputModoConta == mcHEDGING) {
//    if (compradoMercado && vendidoMercado && (quantLotesVenda == quantLotesPosicaoVenda)) {
//     bool ok = trade.PositionCloseBy(ticketCompradoMercado, ticketVendidoMercado);
//
//     if (ok) {
//       if (trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009) {
//         Print("O robô " + NOME_ROBO + " executou a ZERAGEM TOTAL das " + valorTravadoQtdAcoesComprou + " açoes que deveria comprar, do ativo " + _Symbol);
//       } else {
//         Print("ERRO: Retorno inesperado do servidor (trade.PositionCloseBy)");
//
//         return(false);
//       }
//     } else {
//       Print("ERRO: Erro ao enviar trade.PositionCloseBy");
//
//       return(false);
//     }
//    }
//   /*
//    else if (compradoMercado && vendidoMercado && (quantLotesVenda > quantLotesPosicaoVenda)) {
//     bool ok = trade.PositionClosePartial(_Symbol, quantLotesPosicaoVenda, 0);
//
//     if (ok) {
//       if (trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009) {
//         Print("O robô " + NOME_ROBO + " executou a ZERAGEM PARCIAL de " + quantLotesPosicaoVenda + " de " + valorTravadoQtdAcoesComprou + " açoes do ativo " + _Symbol);
//       } else {
//         Print("ERRO: Retorno inesperado do servidor (trade.PositionClosePartial)");
//
//         return(false);
//       }
//     } else {
//       Print("ERRO: Erro ao enviar trade.PositionClosePartial");
//
//       return(false);
//     }
//
//    }
//    */
//  }
//
//   return true;
//}

//--- Medias Móveis e ATR
bool MediasEAtr()
  {

//---MA
   int MediaMovelPequenaHandler = INVALID_HANDLE;
   int MediaMovelMediaHandler = INVALID_HANDLE;
   int MediaMovelGrandeHandler = INVALID_HANDLE;
   int MediaMovelTralingStopHandler = INVALID_HANDLE;
   int atrHandler = INVALID_HANDLE;
   int atrDiarioHandler = INVALID_HANDLE;
   int atrDiarioFiltroPtsHandler = INVALID_HANDLE;
   
   double MediaMovelPequenaBuffer[];
   double MediaMovelMediaBuffer[];
   double MediaMovelGrandeBuffer[];
   double MediaMovelTralingStopBuffer[];
   double atrBuffer[];
   double atrDiarioBuffer[];
   double atrDiarioFiltroPtsBuffer[];
   
   ArraySetAsSeries(MediaMovelPequenaBuffer, true);
   ArraySetAsSeries(MediaMovelMediaBuffer, true);
   ArraySetAsSeries(MediaMovelGrandeBuffer, true);
   ArraySetAsSeries(MediaMovelTralingStopBuffer, true);
   ArraySetAsSeries(atrBuffer, true);
   ArraySetAsSeries(atrDiarioBuffer, true);
   ArraySetAsSeries(atrDiarioFiltroPtsBuffer, true);
   
   string simbolo_media_grande = "WIN$N";
   string simbolo_media_media = "WIN$N";
   string simbolo_ATR = "WIN$N";
   roteamento_symbol = "";
   

   
   if (inputTipoContrato == IndiceCheio) {
      simbolo_media_grande = "IND$N";
      simbolo_media_media = "IND$N";
      simbolo_ATR = "IND$N";
      roteamento_symbol = inputQualTickerAtivo;
   } else if (inputTipoContrato == MiniIndice) {
      simbolo_media_grande = "WIN$N";
      simbolo_media_media = "WIN$N";
      simbolo_ATR = "WIN$N";
      roteamento_symbol = inputQualTickerAtivo;
   } else if (inputTipoContrato == MiniDolar) {
      simbolo_media_grande = "WDO$N";
      simbolo_media_media = "WDO$N";
      simbolo_ATR = "WDO$N";
      roteamento_symbol = inputQualTickerAtivo;
   } else if (inputTipoContrato == DolarCheio) {
      simbolo_media_grande = "DOL$N";
      simbolo_media_media = "DOL$N";
      simbolo_ATR = "DOL$N";
      roteamento_symbol = inputQualTickerAtivo;
   } else {
      simbolo_media_grande = _Symbol;
      simbolo_media_media = _Symbol;
      simbolo_ATR = _Symbol;
      roteamento_symbol = _Symbol;
   }
   
     
  ////---AQUI DEFINE QUAL ATIVO VAI OPERAR
  //if (inputCrossOrder == Mini_Indice) {
  //roteamento_symbol = _Symbol;
  //} else if (inputCrossOrder == Ativa_CrossOrder_Indice) {
  //roteamento_symbol = _Symbol;
  //} else if (inputCrossOrder == Ativa_CrossOrder_Dolar) {
  //roteamento_symbol = _Symbol;
  //}
  
  //--- 

   MediaMovelPequenaHandler = iMA(_Symbol, PERIOD_CURRENT, inputMMPequena, 0, MODE_EMA, PRICE_CLOSE);
   MediaMovelMediaHandler = iMA(simbolo_media_media, PERIOD_CURRENT, inputMMMedia, 0, MODE_EMA, PRICE_CLOSE);
   MediaMovelGrandeHandler = iMA(simbolo_media_grande, PERIOD_CURRENT, inputMMGrande, 0, MODE_EMA, PRICE_CLOSE);
   MediaMovelTralingStopHandler = iMA(_Symbol, PERIOD_CURRENT, inputMMTralingStop, 0, MODE_EMA, PRICE_CLOSE);
   atrHandler = iATR(simbolo_ATR, PERIOD_M15, inputValorATR);
   atrDiarioHandler = iATR(simbolo_ATR, PERIOD_D1, 20);
   atrDiarioFiltroPtsHandler = iATR(simbolo_ATR, PERIOD_D1, inputFiltroAtrDiarioXPeriodos);
   
   if(MediaMovelPequenaHandler != INVALID_HANDLE)
      CopyBuffer(MediaMovelPequenaHandler, 0, 0, 2, MediaMovelPequenaBuffer);
   if(MediaMovelMediaHandler != INVALID_HANDLE)
      CopyBuffer(MediaMovelMediaHandler, 0, 0, 2, MediaMovelMediaBuffer);
   if(MediaMovelGrandeHandler != INVALID_HANDLE)
      CopyBuffer(MediaMovelGrandeHandler, 0, 0, 2, MediaMovelGrandeBuffer);
   if(MediaMovelTralingStopHandler != INVALID_HANDLE)
      CopyBuffer(MediaMovelTralingStopHandler, 0, 0, 2, MediaMovelTralingStopBuffer);
   if(atrHandler != INVALID_HANDLE)
      CopyBuffer(atrHandler, 0, 0, 2, atrBuffer);
   if(atrDiarioHandler != INVALID_HANDLE)
      CopyBuffer(atrDiarioHandler, 0, 0, 2, atrDiarioBuffer);
   if(atrDiarioHandler != INVALID_HANDLE)
      CopyBuffer(atrDiarioFiltroPtsHandler, 0, 0, 5, atrDiarioFiltroPtsBuffer);

   media_movel_pequena = NormalizeDouble(MediaMovelPequenaBuffer[0], _Digits);
   media_movel_media = NormalizeDouble(MediaMovelMediaBuffer[0], _Digits);
   media_movel_grande = NormalizeDouble(MediaMovelGrandeBuffer[0], _Digits);
   media_movel_tralingstop = NormalizeDouble(MediaMovelTralingStopBuffer[1], _Digits);
   atr_stop_15 = NormalizeDouble(atrBuffer[0], _Digits);
   atr_diario = NormalizeDouble(atrDiarioBuffer[0], _Digits);
   atr_diario_filtro_pts = NormalizeDouble(atrDiarioFiltroPtsBuffer[1], _Digits);
   
   
   ChartIndicatorAdd(0,0,MediaMovelPequenaHandler);
   ChartIndicatorAdd(0,0,MediaMovelMediaHandler);
   ChartIndicatorAdd(0,0,MediaMovelGrandeHandler);
   
   //adicionando e removendo o atr do gráfico
   static bool habilitou_atr = false;
   if (inputAtrDiarioHabilitado == Habilitado_Atr_Diario && !habilitou_atr) {
     ChartIndicatorAdd(0,1,atrDiarioFiltroPtsHandler);
     habilitou_atr = true;
   }
   if (inputAtrDiarioHabilitado == Desabilitado_Atr_Diario && habilitou_atr) {
     habilitou_atr = false;
     RemoverIndicadores();
   }
   
   
   //DELETAR A MME DO TRALINGSTOP CASO O TRALLINGSTOP SEJA DESATIVADO
   static bool removeu_indicador = false;
   if (inputTralingStop == Ativa_TralingStop) { 
     ChartIndicatorAdd(0,0,MediaMovelTralingStopHandler);
     removeu_indicador = false;
   } else if ( (inputTralingStop == Desativa_TralingStop) && !removeu_indicador) {
     RemoverIndicadores();
     removeu_indicador = true;
   }
   
//if (!ChartIndicatorAdd(0,0,MediaMovelPequenaHandler)) Print("Erro ao adicionar a Média de " + inputMMPequena + " no gráfico");
//if (!ChartIndicatorAdd(0,0,MediaMovelMediaHandler)) Print("Erro ao adicionar a Média de " + inputMMMedia + " no gráfico");
//if (!ChartIndicatorAdd(0,0,MediaMovelGrandeHandler)) Print("Erro ao adicionar a Média de " + inputMMGrande + " no gráfico");

   return true;

  }

//---
bool VerificarInputs()
  {
  
  Print("NOME_NUMERO_MAGICO = ", NOME_NUMERO_MAGICO);
  Print("VALOR_NUMERO_MAGICO = ", VALOR_NUMERO_MAGICO);
  
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
     {
      Print("ERRO: Verifique se a negociação automatizada é permitida nas configurações do terminal!");
      return false;
     }

   if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
     {
      Print("ERRO: A negociação automatizada é proibida nas configurações do Robô!");
      return false;
     }

    
   if(inputModoConta == mcHEDGING)
     {
      if(GlobalVariableCheck(NOME_NUMERO_MAGICO))
        {
         double valor = GlobalVariableGet(NOME_NUMERO_MAGICO);
         //Print("valor = " + valor);
         if(valor != 0 && valor != VALOR_NUMERO_MAGICO)
           {
            //Print("ERRO: Número Mágico incorreto!");

            //return false;
           }

         //return true;
        }
      else
         GlobalVariableSet(NOME_NUMERO_MAGICO, VALOR_NUMERO_MAGICO);
     }

   if(inputModoConta == mcNETTING && modoConta != ACCOUNT_MARGIN_MODE_RETAIL_NETTING)
     {
      Print(modoConta);
      Print("ERRO: Este robô só poderá ser executado em conta !HEDGING!");
      return false;
     }

   if(inputModoConta == mcHEDGING && modoConta != ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)
     {
      Print(modoConta);
      Print("ERRO: Este robô só poderá ser executado em conta NETTING");
      return false;
     }
     
if (inputQualTickerAtivo == "") {
     Print("ERRO: Defina o ticker que será operado!!");
     return false;
   }

   //if(inputQuantidadeContratos == 0)  // AQUI talvez se colocar  os lotes baseado em R pode Travar o robo no replay
   //  {
   //   Print("ERRO: É obrigatótio informar a Quantidade de Contratos!");
   //   return false;
   //  }
   
    Print("Seja Bem Vindo! Eu sou o escravo da @ Gestão Trader. v2 ");
    Print("Acomode-se e aproveite a viagem. ");

   return true;
  }




//---
bool RemoverIndicadores()
  {
   int subWindows = (int) ChartGetInteger(0, CHART_WINDOWS_TOTAL);

   for(int i = subWindows-1; i>=0; i--)
     {
      int inds = ChartIndicatorsTotal(0,i);

      if(inds >= 1)
        {
         for(int j = inds; j >= 0; j--)
           {
            string indName = ChartIndicatorName(0, i, j);

            ChartIndicatorDelete(0, i, indName);
           }
        }
     }

   return true;
  }


//---
datetime DataExpiracao()
  {
   MqlRates barraAtuala[];

   CopyRates(_Symbol, PERIOD_D1, 0, 1, barraAtuala);

   return barraAtuala[0].time + 86399; //'23:59:59'
  }


//---
int SeAtivoSaiuDoLeilaoMarcarPrimeiraBarra()
  {

   static int contagem_de_barras = 0;
   static bool rodei_o_looping = false;

   static bool virou_alguma_barra_1_minuto = false;
   if(NovoDia() || (contagem_de_barras == 0))
     {
      virou_alguma_barra_1_minuto = false;
      rodei_o_looping = false;
      contagem_de_barras = 0;
     }
   if(NovaBarra1Minuto() && !virou_alguma_barra_1_minuto)
      virou_alguma_barra_1_minuto = true;

   if(!rodei_o_looping)    //para backtestar a funcao com gráfico parado
     {
      //if (virou_alguma_barra_1_minuto && !rodei_o_looping) {

      datetime hoje = iTime(_Symbol,PERIOD_CURRENT,0);
      MqlDateTime hoje_struct, barra;
      TimeToStruct(hoje,hoje_struct);

      int dia_hoje = (int)hoje_struct.day;
      int barra_atual = (int)barra.day;

      for(int i=1; i<200; i++)
        {
         datetime numero_barras_5_minutos = iTime(_Symbol,PERIOD_CURRENT,i);
         MqlDateTime numero_barras_5_minutos_struct;
         TimeToStruct(numero_barras_5_minutos,numero_barras_5_minutos_struct);

         int dia_da_contagem_barras = (int)numero_barras_5_minutos_struct.day;

         if(dia_da_contagem_barras == dia_hoje)
            contagem_de_barras++;
        }

      //Print("contagem_de_barras = ", contagem_de_barras);
      rodei_o_looping = true;

     }

   return (contagem_de_barras);

  }

//---
bool NovaBarra1Minuto()
  {
   static datetime ultimaHora = 0;
   datetime ultimaHoraBarra = (datetime) SeriesInfoInteger(_Symbol, PERIOD_M1, SERIES_LASTBAR_DATE);
   if(ultimaHora == 0)
     {
      ultimaHora = ultimaHoraBarra;
      return false;
     }
   if(ultimaHora != ultimaHoraBarra)
     {
      ultimaHora = ultimaHoraBarra;
      return true;
     }
   return false;
  }

//---
bool NovoDia()
  {
   static datetime today;

   if(today != iTime(_Symbol, PERIOD_D1, 0))
     {
      today = iTime(_Symbol, PERIOD_D1, 0);

      //Print("É um novo dia: ", TimeToString(today));

      return true;
     }
   else   //Print("Não é um novo dia!");

      return false;
  }


//---
bool HorarioPermitidoAbrirPosicao()
  {

   string horaInicialAbrirPosicao = inputHoraInicialAbrirPosicao;  //Aqui Seta o Horário que o robô vai começar a operar
   string horaLimiteComprar = inputHoraLimiteAbrirPosicao;        //Aqui Seta o Horário que o robô vai parar de fazer entradas/operar

   MqlDateTime horaAtual, horarioLimiteAbrirPosicao, horarioInicialAbrirPosicao;

   TimeToStruct(TimeCurrent(), horaAtual);
   TimeToStruct(StringToTime(horaLimiteComprar), horarioLimiteAbrirPosicao);
   TimeToStruct(StringToTime(horaInicialAbrirPosicao), horarioInicialAbrirPosicao);

   if((horarioInicialAbrirPosicao.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min) && (horaAtual.min <= horarioLimiteAbrirPosicao.min))
      return true;
   if((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min))
      return true;
   if((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioInicialAbrirPosicao.hour) && (horaAtual.hour > horarioInicialAbrirPosicao.hour) && (horaAtual.hour < horarioLimiteAbrirPosicao.hour))
      return true;
   if((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.min <= horarioLimiteAbrirPosicao.min))
      return true;
   if(horarioInicialAbrirPosicao.hour > horarioLimiteAbrirPosicao.hour)
     {
     
      FecharOrdensPendentesCompraDoAtivo();  // Por ever | Fecha ordens stop pendentes COMPRA após o almoço
      FecharOrdensPendentesVendaDoAtivo();   // Por ever | Fecha ordens stop pendentes COMPRA após o almoço
      
      ExpertRemove();

      Print("ERRO: Os horários fornecidos estão inválidos!");
     }

   return false;
  }

//---
bool HorarioNoveECinco() {
  string horaInicialAbrirPosicao = "09:05";  //Aqui Seta o Horário que o robô vai começar a operar
  string horaLimiteComprar = "17:55";        //Aqui Seta o Horário que o robô vai parar de fazer entradas/operar
   
  MqlDateTime horaAtual, horarioLimiteAbrirPosicao, horarioInicialAbrirPosicao;
   
  TimeToStruct(TimeCurrent(), horaAtual); 
  TimeToStruct(StringToTime(horaLimiteComprar), horarioLimiteAbrirPosicao);
  TimeToStruct(StringToTime(horaInicialAbrirPosicao), horarioInicialAbrirPosicao);
 
  if ((horarioInicialAbrirPosicao.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min) && (horaAtual.min <= horarioLimiteAbrirPosicao.min)) return true;
  if ((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min)) return true;
  if ((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioInicialAbrirPosicao.hour) && (horaAtual.hour > horarioInicialAbrirPosicao.hour) && (horaAtual.hour < horarioLimiteAbrirPosicao.hour)) return true;
  if ((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.min <= horarioLimiteAbrirPosicao.min)) return true;
    
  return false;
}
//+------------------------------------------------------------------+



//---
bool HorarioFechamentoPregaoTodasOrdens()
  {
   string hora = inputHorarioVerao;

   MqlDateTime horaAtual, horarioLimiteFecharOrdem;
   TimeToStruct(TimeCurrent(), horaAtual);
   TimeToStruct(StringToTime(hora), horarioLimiteFecharOrdem);

//Print("horarioFechamentoPregao = " + horarioLimiteFecharOrdem.day + "/" + horarioLimiteFecharOrdem.mon + "/" + horarioLimiteFecharOrdem.year + " " + horarioLimiteFecharOrdem.hour + ":" + horarioLimiteFecharOrdem.min);

   if(horaAtual.hour > horarioLimiteFecharOrdem.hour)
      return true;
   if((horaAtual.hour == horarioLimiteFecharOrdem.hour) && (horaAtual.min >= horarioLimiteFecharOrdem.min))
      return true;

   return false;
  }

bool HorarioFechamentoPregaoTodasOrdens2() {


   ushort hora1 = StringGetCharacter(inputHorarioVerao,0);
   ushort hora2 = StringGetCharacter(inputHorarioVerao,1);
   ushort min1 = StringGetCharacter(inputHorarioVerao,3);
   ushort min2 = StringGetCharacter(inputHorarioVerao,4);
   string valor_hora1 = ShortToString(hora1);
   string valor_hora2 = ShortToString(hora2);
   string valor_min1 = ShortToString(min1);
   string valor_min2 = ShortToString(min2);
   
   uint HoraInicial_ = uint(valor_hora1 + valor_hora2);
   uint MinInicial_ = uint(valor_min1 + valor_min2);
   uint HoraFinal_ = 18;
   uint MinFinal_ = 00;
   
   // StringSubstr -> proibido !!! -> torna o backtest extremamente lento !!!
   MqlRates dailyBar[];
   int copied = CopyRates(_Symbol,PERIOD_D1,0,1,dailyBar);
   if(copied==1)
     {
      // datetime dateStart = dailyBar[0].time; // '2019.11.15 00:00:00'
      datetime tempoInicial = dailyBar[0].time + (HoraInicial_*60*60) + (MinInicial_*60);
      datetime tempoFinal = dailyBar[0].time + (HoraFinal_*60*60) + (MinFinal_*60);
      datetime timeNow = TimeCurrent();
      //
      if( timeNow>=tempoInicial && timeNow<tempoFinal )
        {
         return(true);
        }
     }
   else
     {
      return(false);
     }
   //
   return(false);

}

//---
bool FecharPosicaoAbertas()
  {
   int positionsTotal = PositionsTotal();

   for(int i = 0; i < positionsTotal && !IsStopped(); i++)
     {
      ulong posTicket = PositionGetTicket(i);

      if(PositionSelectByTicket(posTicket))
        {
         ulong posMagic = PositionGetInteger(POSITION_MAGIC);

         string posSymbol = PositionGetString(POSITION_SYMBOL);

         ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

         // já tenho posição com meu magic number
         //if(posSymbol == _Symbol && posMagic == VALOR_NUMERO_MAGICO) {
         if(inputModoConta == mcNETTING)
           {
            if(posSymbol == roteamento_symbol)
              {
               if(posType == POSITION_TYPE_BUY || posType == POSITION_TYPE_SELL)
                 {
                  FecharPosicao(posTicket, posType == POSITION_TYPE_BUY ? true : false);
                 }
              }
           }
         else
           {
            if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
              {
               if(posType == POSITION_TYPE_BUY || posType == POSITION_TYPE_SELL)
                 {
                  FecharPosicao(posTicket, posType == POSITION_TYPE_BUY ? true : false);
                 }
              }
           }
        }
     }
   return true;
  }


//---
bool FecharOrdensPendentesVendaDoAtivo()
  {
   int ordersTotal = OrdersTotal();

   for(int i=0; i < ordersTotal && !IsStopped(); i++)
     {
      ulong orderTicket = OrderGetTicket(i);

      if(OrderSelect(orderTicket))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {
            if(orderSymbol == roteamento_symbol)
              {
               if(orderType == ORDER_TYPE_SELL_LIMIT || ORDER_TYPE_SELL_STOP )  // Ever adicionou BUY STOP || ORDER_TYPE_SELL_STOP 
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  Print(" Fechou a ordem por FecharOrdensPendentesVendaDoAtivo() ");
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
         else
           {

            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
               if(orderType == ORDER_TYPE_SELL_LIMIT)
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
        }
     }

   return true;
  }


//---
bool FecharOrdensPendentesCompraDoAtivo()
  {
   int ordersTotal = OrdersTotal();

   for(int i=0; i < ordersTotal && !IsStopped(); i++)
     {
      ulong orderTicket = OrderGetTicket(i);

      if(OrderSelect(orderTicket))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {
            if(orderSymbol == roteamento_symbol)
              {
               if(orderType == ORDER_TYPE_BUY_LIMIT || ORDER_TYPE_BUY_STOP  ) // Ever adicionou BUY STOP || ORDER_TYPE_BUY_STOP 
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  Print(" Fechou a ordem por FecharOrdensPendentesCompraDoAtivo() ");
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
         else
           {

            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
               if(orderType == ORDER_TYPE_BUY_LIMIT)
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
        }
     }

   return true;
  }

//---
bool FecharOrdensPendentesVendaDoAtivo2()
  {
   int ordersTotal = OrdersTotal();

   for(int i=0; i < ordersTotal && !IsStopped(); i++)
     {
      ulong orderTicket = OrderGetTicket(i);

      if(OrderSelect(orderTicket))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {
            if(orderSymbol == roteamento_symbol)
              {
               if(orderType == ORDER_TYPE_SELL_LIMIT)  // Ever adicionou BUY STOP || ORDER_TYPE_SELL_STOP 
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  Print(" Fechou a ordem por FecharOrdensPendentesVendaDoAtivo2() ");
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
         else
           {

            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
               if(orderType == ORDER_TYPE_SELL_LIMIT)
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
        }
     }

   return true;
  }


//---
bool FecharOrdensPendentesCompraDoAtivo2()
  {
   int ordersTotal = OrdersTotal();

   for(int i=0; i < ordersTotal && !IsStopped(); i++)
     {
      ulong orderTicket = OrderGetTicket(i);

      if(OrderSelect(orderTicket))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {
            if(orderSymbol == roteamento_symbol)
              {
               if(orderType == ORDER_TYPE_BUY_LIMIT) // Ever adicionou BUY STOP || ORDER_TYPE_BUY_STOP 
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  Print(" Fechou a ordem por FecharOrdensPendentesCompraDoAtivo2() ");
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
         else
           {

            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
               if(orderType == ORDER_TYPE_BUY_LIMIT)
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");

                     return(false);
                    }
                 }
              }
           }
        }
     }

   return true;
  }

//---
bool FecharPosicao(ulong ticket, bool compra)
  {
   string sinal = compra ? "COMPRA" : "VENDA";

   string msgOK = "Ordem de " + sinal  + " fechada com sucesso!";

   string msgErro = "ERRO: Erro ao enviar trade.PositionClose (" + sinal + ")";

   bool ok = trade.PositionClose(ticket);

   if(ok)
     {
      if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
        {
         Print(msgOK);
        }
      else
        {
         Print("ERRO: Retorno inesperado do servidor");

         return(false);
        }
     }
   else
     {
      Print(msgErro);

      return(false);
     }

   return true;
  }



//---
bool FecharOrdensPendentesSellStopAtivo()
  {
   int ordersTotal = OrdersTotal();

   for(int i=0; i < ordersTotal && !IsStopped(); i++)
     {
      ulong orderTicket = OrderGetTicket(i);

      if(OrderSelect(orderTicket))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {
            if(orderSymbol == roteamento_symbol)
              {
      	       string comentario = OrderGetString(ORDER_COMMENT);
               if(orderType == ORDER_TYPE_SELL_STOP)  
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  Print(" Fechou a ordem por FecharOrdensPendentesVendaDoAtivo2() ");
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem SellStop do ativo" + _Symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.SellStop (VENDA STOP)");

                     return(false);
                    }
                 }
              }
           }
         else
           {

            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
      	       string comentario = OrderGetString(ORDER_COMMENT);
               if(orderType == ORDER_TYPE_SELL_STOP)  
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        Print("Ordem de VENDA STOP excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem SellStop do ativo" + _Symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.SellStop (VENDA STOP)");

                     return(false);
                    }
                 }
              }
           }
        }
     }

   return true;
  }


//---
bool FecharOrdensPendentesBuyStopAtivo()
  {
   int ordersTotal = OrdersTotal();

   for(int i=0; i < ordersTotal && !IsStopped(); i++)
     {
      ulong orderTicket = OrderGetTicket(i);

      if(OrderSelect(orderTicket))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {
            if(orderSymbol == roteamento_symbol)
              {
      	       string comentario = OrderGetString(ORDER_COMMENT);
               if(orderType == ORDER_TYPE_BUY_STOP)  
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  Print(" Fechou a ordem por FecharOrdensPendentesCompraDoAtivo2() ");
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        //Print("Ordem de VENDA PENDENTE excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem BuyStop do ativo" + _Symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.BuyStop (COMPRA STOP)");

                     return(false);
                    }
                 }
              }
           }
         else
           {

            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
      	       string comentario = OrderGetString(ORDER_COMMENT);
               if(orderType == ORDER_TYPE_BUY_STOP)  
                 {
                  bool ok = trade.OrderDelete(orderTicket);
                  
                  if(ok)
                    {
                     if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
                       {
                        Print("Ordem de COMPRA STOP excluida com sucesso!");
                       }
                     else
                       {
                        Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem BuyStop do ativo" + _Symbol);

                        return(false);
                       }
                    }
                  else
                    {
                     Print("ERRO: Erro ao enviar trade.BuyStop (COMPRA STOP)");

                     return(false);
                    }
                 }
              }
           }
        }
     }

   return true;
  }

//---
bool VerificarOrdensPosicoes()   //modificou algumas coisas do robô original
  {

   compradoMercado  = false;
   vendidoMercado   = false;
   compradoPendente = false;
   vendidoPendente  = false;
   compradoStop = false;
   vendidoStop = false;

   ticketCompradoMercado  = 0;
   ticketVendidoMercado   = 0;
   ticketCompradoPendente = 0;
   ticketVendidoPendente  = 0;
   ticketVendidoStop = 0;
   ticketCompradoStop = 0;


   quantLotesPosicaoCompra = 0; //é o numero de lotesem posicao de compra
   quantLotesPosicaoVenda = 0; //é o numero de lotes em posicao de venda
   quantLotesOrdensVenda = 0; //é a quantidade de Lotes de Ordens de Venda (pendurada)
   quantLotesOrdensCompra = 0; //é a quantidade de Lotes de Ordens de Compra (pendurada)
   quantPosicoesCompraExecutadasNoAtivo = 0;
   quantPosicoesVendaExecutadasNoAtivo = 0;
   quantPosicoesCompraExecutadasGlobal = 0;
   quantPosicoesVendaExecutadasGlobal = 0;
   quantOrdensCompraAbertasNoAtivo = 0;
   quantOrdensVendaAbertasNoAtivo = 0;
   quantOrdensCompraAbertasGlobal = 0;
   quantOrdensVendaAbertasGlobal = 0;

   quantLotesOrdensStopCompra = 0;
   quantLotesOrdensStopVenda = 0;


   precoDeCompra = 0;
   precoDeVenda = 0;
   precoPendurouOrdemCompra = 0;
   precoPendurouOrdemVenda = 0;
   precoPendurouOrdemStopCompra = 0;
   precoPendurouOrdemStopVenda = 0;
   maiorOrdemDeCompra = 0;
   menorOrdemDeVenda = 0;
   primeiroPrecoOrdemDeVenda = 0;
   existem_ordem_entao_nao_pode_monitorar_compra = false;
   existem_ordem_entao_nao_pode_monitorar_venda = false;
   bool o_loop_so_pode_passar_1x = false;
//se_ta_vendido_no_ask_ou_mais = false;
//se_ta_comprado_no_bid_ou_menos = false;



//+------------------------------------------------------------------+
//| LOOP NAS ORDENS - COMPRA/VENDA PENDENTE AINDA NÃO EXECUTADAS     |
//+------------------------------------------------------------------+
   int ordersTotal = OrdersTotal();

   for(int i=0; i < ordersTotal && !IsStopped(); i++)
     {
      ulong orderTicket = OrderGetTicket(i);

      if(OrderSelect(orderTicket))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {

            if(orderType == ORDER_TYPE_BUY_LIMIT)
               quantOrdensCompraAbertasGlobal++;
            if(orderType == ORDER_TYPE_SELL_LIMIT)
               quantOrdensVendaAbertasGlobal++;

            if(orderSymbol == roteamento_symbol)
              {
               if(orderType == ORDER_TYPE_BUY_LIMIT)
                 {

                  quantOrdensCompraAbertasNoAtivo++;

                  compradoPendente = true;

                  quantLotesOrdensCompra = (quantLotesOrdensCompra + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));

                  ticketCompradoPendente = orderTicket;

                  precoPendurouOrdemCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);

                  if(precoPendurouOrdemCompra > maiorOrdemDeCompra)
                     maiorOrdemDeCompra = NormalizeDouble(precoPendurouOrdemCompra, _Digits);

                 }

               if(orderType == ORDER_TYPE_SELL_LIMIT)
                 {

                  quantOrdensVendaAbertasNoAtivo++;

                  vendidoPendente = true;

                  quantLotesOrdensVenda = (quantLotesOrdensVenda + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));

                  ticketVendidoPendente = orderTicket;

                  precoPendurouOrdemVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);

                 }
              }
           }
         else
           {

            if((orderMagic == VALOR_NUMERO_MAGICO) && (orderType == ORDER_TYPE_BUY_LIMIT))
               quantOrdensCompraAbertasGlobal++;
            if((orderMagic == VALOR_NUMERO_MAGICO) && (orderType == ORDER_TYPE_SELL_LIMIT))
               quantOrdensVendaAbertasGlobal++;

            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
               if(orderType == ORDER_TYPE_BUY_LIMIT)
                 {

                  quantOrdensCompraAbertasNoAtivo++;

                  compradoPendente = true;

                  quantLotesOrdensCompra = (quantLotesOrdensCompra + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));

                  ticketCompradoPendente = orderTicket;

                  precoPendurouOrdemCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);

                 }

               if(orderType == ORDER_TYPE_SELL_LIMIT)
                 {

                  quantOrdensVendaAbertasNoAtivo++;

                  vendidoPendente = true;

                  quantLotesOrdensVenda = (quantLotesOrdensVenda + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));

                  ticketVendidoPendente = orderTicket;

                  precoPendurouOrdemVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);


                 }
              }
           }
        }
     }


//+---------------------------------------------------------------------------+
//| LOOP NAS POSIÇÕES - COMPRA/VENDA A MERCADO OU ORDENS QUE FORAM EXECUTADAS |
//+---------------------------------------------------------------------------+
   int positionsTotal = PositionsTotal();

   for(int i=0; i < positionsTotal && !IsStopped(); i++)
     {
      ulong posTicket = PositionGetTicket(i);

      if(PositionSelectByTicket(posTicket))
        {
         ulong posMagic = PositionGetInteger(POSITION_MAGIC);

         string posSymbol = PositionGetString(POSITION_SYMBOL);

         ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

         if(inputModoConta == mcNETTING)
           {

            if(posType == POSITION_TYPE_BUY)
               quantPosicoesCompraExecutadasGlobal++;
            if(posType == POSITION_TYPE_SELL)
               quantPosicoesVendaExecutadasGlobal++;

            if(posSymbol == roteamento_symbol)
              {
               if(posType == POSITION_TYPE_BUY)
                 {

                  quantPosicoesCompraExecutadasNoAtivo++;

                  compradoMercado = true;

                  quantLotesPosicaoCompra = (quantLotesPosicaoCompra + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));

                  ticketCompradoMercado = posTicket;

                  precoDeCompra = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);

                  //if ((ask_primeira_melhor_oferta_preco - inputCentavosStopar) == precoDeCompra) se_ta_comprado_no_bid_ou_menos = true; //aqui marca se está comprado no preço do BID/melhor oferta de compra

                 }

               if(posType == POSITION_TYPE_SELL)
                 {

                  quantPosicoesVendaExecutadasNoAtivo++;

                  vendidoMercado  = true;

                  quantLotesPosicaoVenda = (quantLotesPosicaoVenda + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));

                  ticketVendidoMercado = posTicket;

                  precoDeVenda = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);

                  //if ((bid_primeira_melhor_oferta_preco + inputCentavosStopar) == precoDeVenda) se_ta_vendido_no_ask_ou_mais = true; //aqui marca se está vendido no preço do ASK/melhor oferta de venda

                 }
              }
           }
         else
           {
            if((posMagic == VALOR_NUMERO_MAGICO) && (posType == POSITION_TYPE_BUY))
               quantPosicoesCompraExecutadasGlobal++;
            if((posMagic == VALOR_NUMERO_MAGICO) && (posType == POSITION_TYPE_SELL))
               quantPosicoesVendaExecutadasGlobal++;

            if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
              {
               if(posType == POSITION_TYPE_BUY)
                 {

                  quantPosicoesCompraExecutadasNoAtivo++;

                  compradoMercado = true;

                  quantLotesPosicaoCompra = (quantLotesPosicaoCompra + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));

                  ticketCompradoMercado = posTicket;

                  precoDeCompra = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);
                 }

               if(posType == POSITION_TYPE_SELL)
                 {

                  quantPosicoesVendaExecutadasNoAtivo++;

                  vendidoMercado  = true;

                  quantLotesPosicaoVenda = (quantLotesPosicaoVenda + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));

                  ticketVendidoMercado = posTicket;

                  precoDeVenda = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);

                 }
              }
           }
        }
     }


//+------------------------------------------------------------------+
//| LOOP NAS ORDENS - COMPRA/VENDA STOP                              |
//+------------------------------------------------------------------+
   int ordersTotalStop = OrdersTotal();

   for(int i=0; i < ordersTotalStop && !IsStopped(); i++)
     {
      ulong orderTicketStop = OrderGetTicket(i);

      if(OrderSelect(orderTicketStop))
        {
         ulong orderMagic = OrderGetInteger(ORDER_MAGIC);

         string orderSymbol = OrderGetString(ORDER_SYMBOL);

         ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);

         if(inputModoConta == mcNETTING)
           {

            // if (orderType == ORDER_TYPE_BUY_LIMIT) quantOrdensCompraAbertas++;
            //if (orderType == ORDER_TYPE_SELL_LIMIT) quantOrdensVendaAbertas++;

            if(orderSymbol == roteamento_symbol)
              {
               if(orderType == ORDER_TYPE_BUY_STOP)
                 {

                  quantLotesOrdensStopCompra = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);

                  compradoStop = true;
                  
                  precoPendurouOrdemStopCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);

                  ticketCompradoStop = orderTicketStop;

                 }

               if(orderType == ORDER_TYPE_SELL_STOP)
                 {

                  quantLotesOrdensStopVenda = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);

                  vendidoStop = true;
                  
                  precoPendurouOrdemStopVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);

                  ticketVendidoStop = orderTicketStop;

                 }
              }
           }
         else
           {

            //  if (orderType == ORDER_TYPE_BUY_LIMIT) quantOrdensCompraAbertas++;
            //if (orderType == ORDER_TYPE_SELL_LIMIT) quantOrdensVendaAbertas++;
            if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
              {
               if(orderType == ORDER_TYPE_BUY_STOP)
                 {

                  quantLotesOrdensStopCompra = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);

                  compradoStop = true;
                  
                  precoPendurouOrdemStopCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);

                  ticketCompradoStop = orderTicketStop;

                 }

               if(orderType == ORDER_TYPE_SELL_STOP)
                 {

                  quantLotesOrdensStopVenda = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);

                  vendidoStop = true;
                  
                  precoPendurouOrdemStopVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);

                  ticketVendidoStop = orderTicketStop;

                 }
              }
           }
        }
     }


   return true;
  }
//+------------------------------------------------------------------+


void QuantidadeContratosDoR()
{

  //QUANTIDADE DE CONTRATOS EM R FIXO

  if(inputCrossOrder == Mini_Indice)
   {
   NomeTipoDeContrato = "Mini Indice";
   multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickMiniIndice;
   minimoDeContratos = 1;
   }
   
  if(inputCrossOrder == Indice_Cheio)
   {
   NomeTipoDeContrato = "Indice Cheio";
   multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickIndiceCheio;
   minimoDeContratos = 5;
   }

   //LIBERA TRADE SE QUANTIDADE DE CONTRATOS FOR MAIOR QUE 1
   if(quantidadeContratos >= minimoDeContratos)
   {
   podeTreidar = true;
   }
   else
     {
      podeTreidar = false;
     }
   

     valorStopEmReais = ((MathRound(atr_stop_15/5))*5) * multiplicadorFinanceiroDoContrato;
     seraQueAredonda = valorDoREmReais/valorStopEmReais - MathFloor(valorDoREmReais/valorStopEmReais);
     
     if(seraQueAredonda >= 0.8)
       {
       quantidadeContratos = MathCeil(valorDoREmReais/valorStopEmReais) * minimoDeContratos;
       aredondaPeloTOPO = true;
       }
       else
       {
       quantidadeContratos = MathFloor(valorDoREmReais/valorStopEmReais) * minimoDeContratos;
       aredondaPeloFUNDO = true;
       }

   //  return;
}


void QuantidadeContratosPorPorcentagemDeConta()
{
   valorBalancoDaConta = AccountInfoDouble(ACCOUNT_BALANCE);
   
  //QUANTIDADE DE CONTRATOS BASEADO EM PORCENTAGEM DE CONTA
  if(inputPorcentagemConta1_5 == PorcentagemConta1_0)
  {
   RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta1_0;
  }
  if(inputPorcentagemConta1_5 == PorcentagemConta1_5)
  {
   RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta1_5;
  }
  if(inputPorcentagemConta1_5 == PorcentagemConta2_0)
  {
   RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta2_0;
  }
  if(inputPorcentagemConta1_5 == PorcentagemConta2_5)
  {
  RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta2_5;
  }
  if(inputPorcentagemConta1_5 == PorcentagemConta3_0)
  {
  RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta3_0;
  }
  if(inputPorcentagemConta1_5 == PorcentagemConta4_0)
  {
  RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta4_0;
  }
  if(inputPorcentagemConta1_5 == PorcentagemConta5_0)
  {
  RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta5_0;
  }
   if(inputPorcentagemConta1_5 == PorcentagemConta10_0)
  {
  RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta10_0;
  }
   if(inputPorcentagemConta1_5 == PorcentagemConta15_0)
  {
  RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta15_0;
  }
   if(inputPorcentagemConta1_5 == PorcentagemConta20_0)
  {
  RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta20_0;
  }
  
 
  //CONTINUA LOGICA COMO NA FUNÇÃO DE CALCULO DE R FIXO
  if(inputCrossOrder == Mini_Indice)
   {
   NomeTipoDeContrato = "Mini Indice";
   multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickMiniIndice;
   minimoDeContratos = 1;
   }
   
   if(inputCrossOrder == Indice_Cheio)
   {
   NomeTipoDeContrato = "Indice Cheio";
   multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickIndiceCheio;
   minimoDeContratos = 5;
   }
  
   //LIBERA TRADE SE QUANTIDADE DE CONTRATOS FOR MAIOR QUE 1
   if(quantidadeContratos >= minimoDeContratos)
   {
   podeTreidar = true;
   }
   else
     {
      podeTreidar = false;
     }
  
    valorStopEmReais = ((MathRound(atr_stop_15/tickerBase))*tickerBase) * multiplicadorFinanceiroDoContrato;
     seraQueAredonda = RPeloBalancoDaConta/valorStopEmReais - MathFloor(RPeloBalancoDaConta/valorStopEmReais);
     
     if(seraQueAredonda >= 0.8)
       {
       quantidadeContratos = MathCeil(RPeloBalancoDaConta/valorStopEmReais) * minimoDeContratos;
       aredondaPeloTOPO = true;
       }
       else
       {
       quantidadeContratos = MathFloor(RPeloBalancoDaConta/valorStopEmReais) * minimoDeContratos;
       aredondaPeloFUNDO = true;
       }
  
  
}

//---
bool TralingStop() {


  double fechamento_ultima_barra = iClose(_Symbol,PERIOD_CURRENT,1);
  
  //fiz um comentario no traling stop

  //LÓGICA PARA FECHAR O TRALING STOP DA COMPRA....
  if (compradoMercado && (fechamento_ultima_barra < media_movel_tralingstop) && (inputTralingStop == Ativa_TralingStop)) {
    
    FecharPosicaoAbertas();
    
  //LÓGICA PARA FECHAR O TRALING STOP DA VENDA....
  } else if (vendidoMercado && (fechamento_ultima_barra > media_movel_tralingstop) && (inputTralingStop == Ativa_TralingStop)) {

    FecharPosicaoAbertas();
    
  }
  
return true;
}


//---
bool AlvoDaCompra() {

  VerificarOrdensPosicoes(); //verifica a situação das ordens
  
  if (inputAlvoPelaMinMaxOuEntrada == Alvo_Pela_Entrada) {
    alvo_compra = (precoDeCompra + (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
  } else { 
    alvo_compra = (maxima_do_dia + (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
  }
  //Print("alvo_compra = ",alvo_compra);
  static bool enviou_alvo_da_compra = false;
  if (!compradoMercado) { 
  enviou_alvo_da_compra = false;
  FecharOrdensPendentesVendaDoAtivo2();
  }  
  
  //--------marcador de XXs para enfiar o alvo---------
  ulong hora_atual_servidor = TimeCurrent();
  static bool esperou_XXs_para_colocar_alvos = false; //inicialmente a variavel é falsa
  static bool marcou_horario_da_posicao = false; //inicialmente a variavel é falsa, vc nao tem posicao
  static ulong horario_da_posicao = 999999999999;
  int segundos_esperar_para_colocar_ordem_alvo = 30; //espera XX segundos para colocar o alvo
  
  if (!marcou_horario_da_posicao && compradoMercado) {
    horario_da_posicao = TimeCurrent(); //marca que tem posicao de compra ou venda
    marcou_horario_da_posicao = true; //sim, agora vc tem posicao
  }
  
  if (hora_atual_servidor > (horario_da_posicao+segundos_esperar_para_colocar_ordem_alvo)) { //ora, se tem posicao, entao comeca a conta 30s para, depois, marcar uma variavel positiva para colocar a ordem
    esperou_XXs_para_colocar_alvos = true; //marca a variavel positiva para colocar a ordem
  }  
  
  if (!compradoMercado) { //se nao tem mais posicao, volta todas as variaveis para a posicao inicial
    marcou_horario_da_posicao = false; //volta a variavel para seu estado original
    esperou_XXs_para_colocar_alvos = false; //volta a variavel para seu estado original
    horario_da_posicao = 999999999999;
  }
  //----------------------------------------------------
    
  if (compradoMercado && esperou_XXs_para_colocar_alvos && VerificarOrdensPosicoes() && !vendidoPendente && (quantLotesPosicaoCompra <= quantidadeContratos) && !enviou_alvo_da_compra) { 
    bool ok = trade.SellLimit(quantLotesPosicaoCompra, alvo_compra, roteamento_symbol, 0, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO); 
    enviou_alvo_da_compra = true;
    n_ordens_enviadas++; //proteção envio massivo de ordens
    if(ok)
      {
       if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
         {
          Print("Alvo da Compra enviado com sucesso!");
         }
       else
         {
          Print("ERRO1: Alvo da Compra");
         }
      }
    else
      {
       Print("ERRO2: Alvo da Compra");
      }
   }
   
   
  //SE CHEGOU NO ALVO, FECHA A MERCADO POSIÇÕES REMANESCENTES 
  
  if (compradoMercado && (quantLotesPosicaoCompra < quantidadeContratos) && (tick.last > (alvo_compra-(tickerBase*10)))) FecharPosicaoAbertas();
  
return true;
}


//---
bool AlvoDaVenda() {

  VerificarOrdensPosicoes(); //verifica a situação das ordens
  
  if (inputAlvoPelaMinMaxOuEntrada == Alvo_Pela_Entrada) {
    alvo_venda = (precoDeVenda - (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
  } else {
    alvo_venda = (minima_do_dia - (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
  }
  
  static bool enviou_alvo_da_venda = false;
  if (!vendidoMercado) {
  enviou_alvo_da_venda = false;
  FecharOrdensPendentesCompraDoAtivo2();
  } 
  
  //--------marcador de XXs para enfiar o alvo---------
  ulong hora_atual_servidor = TimeCurrent();
  static bool esperou_XXs_para_colocar_alvos = false; //inicialmente a variavel é falsa
  static bool marcou_horario_da_posicao = false; //inicialmente a variavel é falsa, vc nao tem posicao
  static ulong horario_da_posicao = 999999999999;
  int segundos_esperar_para_colocar_ordem_alvo = 30; //espera XX segundos para colocar o alvo
  
  if (!marcou_horario_da_posicao && vendidoMercado) {
    horario_da_posicao = TimeCurrent(); //marca que tem posicao de compra ou venda
    marcou_horario_da_posicao = true; //sim, agora vc tem posicao
  }
  
  if (hora_atual_servidor > (horario_da_posicao+segundos_esperar_para_colocar_ordem_alvo)) { //ora, se tem posicao, entao comeca a conta 30s para, depois, marcar uma variavel positiva para colocar a ordem
    esperou_XXs_para_colocar_alvos = true; //marca a variavel positiva para colocar a ordem
  }  
  
  if (!vendidoMercado) { //se nao tem mais posicao, volta todas as variaveis para a posicao inicial
    marcou_horario_da_posicao = false; //volta a variavel para seu estado original
    esperou_XXs_para_colocar_alvos = false; //volta a variavel para seu estado original
    horario_da_posicao = 999999999999;
  }
  //----------------------------------------------------
  
   
  if (vendidoMercado && esperou_XXs_para_colocar_alvos && VerificarOrdensPosicoes() && !compradoPendente && (quantLotesPosicaoVenda <= quantidadeContratos) && !enviou_alvo_da_venda) { 
    bool ok = trade.BuyLimit(quantLotesPosicaoVenda, alvo_venda, roteamento_symbol, 0, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO); 
    enviou_alvo_da_venda = true;
    n_ordens_enviadas++; //proteção envio massivo de ordens
    if(ok)
      {
       if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
         {
          Print("Alvo da Venda enviado com sucesso!");
         }
       else
         {
          Print("ERRO1: Alvo da Venda");
         }
      }
    else
      {
       Print("ERRO2: Alvo da Venda");
      }
   }

  //SE CHEGOU NO ALVO, FECHA A MERCADO POSIÇÕES REMANESCENTES 
  
  if (vendidoMercado && (quantLotesPosicaoVenda < quantidadeContratos) && (tick.last < (alvo_venda+(tickerBase*(tickerBase*2))))) FecharPosicaoAbertas();
  
return true;
}

//---
bool FecharPosicoesContaHedge() {

  VerificarOrdensPosicoes(); //verifica a situação das ordens
  //+----------------------------------------------------------------+
  //| SE TIVER UMA COMPRA E VENDA POSICIONADAS, FECHA UMA PELA OUTRA |
  //+----------------------------------------------------------------+
  if (inputModoConta == mcHEDGING) {
    if (compradoMercado && vendidoMercado && (quantLotesPosicaoCompra == quantLotesPosicaoVenda)) {
    double quantidade_que_comprou_ou_vendeu = quantLotesPosicaoCompra;
      bool ok = trade.PositionCloseBy(ticketCompradoMercado, ticketVendidoMercado);

      if (ok) {
        if (trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009) {
          Print("O robô " + NOME_ROBO + " executou a ZERAGEM TOTAL da posição de " + DoubleToString(quantidade_que_comprou_ou_vendeu, _Digits) + " contrato/açoes, do ativo " + _Symbol);
        } else {
          Print("ERRO1: Retorno inesperado do servidor (trade.PositionCloseBy)");

          return(false);
        }
      } else {
        Print("ERRO2: Erro ao enviar trade.PositionCloseBy");

        return(false);
      }
    }
  }

   return true;
}
//+------------------------------------------------------------------+


bool ProtecaoContraLooping() {
  
  ulong hora_atual = TimeLocal();
  //double posicoesEordensAbertas = NormalizeDouble(quantPosicoesExecutadasGlobal+quantOrdensCompraAbertas, _Digits);
  if (((inputModoDeMercado == ContaReal) || (tipoConta == ACCOUNT_TRADE_MODE_REAL)) && (hora_atual > (horario_executou_robo+30))) {
    if ((quantLotesPosicaoCompra || quantLotesPosicaoVenda) > quantidadeContratos) {
   
    Print("MOTIVO 1: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO.");
    FecharOrdensPendentesCompraDoAtivo();
    FecharOrdensPendentesVendaDoAtivo();
    FecharPosicaoAbertas();
    ExpertRemove();
  
    }
    
    if ((quantLotesOrdensVenda || quantLotesOrdensCompra) > quantidadeContratos) {
   
    Print("MOTIVO 2: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO, VEJA SE NÃO TOMOU MAIS POSIÇÃO QUE O SETADO NO CAIXA. FAVOR VERIFICAR O QUE HOUVE ANTES DE RODAR DE NOVO");
    FecharOrdensPendentesCompraDoAtivo();
    FecharOrdensPendentesVendaDoAtivo();
    FecharPosicaoAbertas();
    ExpertRemove();
  
    }
    
    if ((quantLotesOrdensStopCompra || quantLotesOrdensStopVenda) > quantidadeContratos) {
    
    Print("MOTIVO 3: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO, VEJA SE NÃO TOMOU MAIS POSIÇÃO QUE O SETADO NO CAIXA. FAVOR VERIFICAR O QUE HOUVE ANTES DE RODAR DE NOVO");
    FecharOrdensPendentesCompraDoAtivo();
    FecharOrdensPendentesVendaDoAtivo();
    FecharPosicaoAbertas();
    ExpertRemove();
  
    }
    
    if (quantos_trades_fez_no_dia > 7) {
    
    Print("MOTIVO 4: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO, VEJA SE NÃO TOMOU MAIS POSIÇÃO QUE O SETADO NO CAIXA. FAVOR VERIFICAR O QUE HOUVE ANTES DE RODAR DE NOVO");
    FecharOrdensPendentesCompraDoAtivo();
    FecharOrdensPendentesVendaDoAtivo();
    FecharPosicaoAbertas();
    ExpertRemove();
  
    }
  }

  return true;
}

bool ProtecaoEnvioMassivoOrdens() {
  
  if (inputModoDeMercado == Backtest) {
  
    int segundos_pausar_robo = 3600;
    int intervalo_segundos = 4;
    int n_maximo_ordens_enviadas_em_x_segundos = 5;
    static ulong hora_que_enviou_a_primeira_ordem = 0;
    static bool marcou_hora_primeira_ordem = false;
    ulong hora_atual_servidor = TimeCurrent();
    
    if (n_ordens_enviadas == 1 && !marcou_hora_primeira_ordem) {
    hora_que_enviou_a_primeira_ordem = TimeCurrent();
    marcou_hora_primeira_ordem = true;
    }
    
    if (hora_atual_servidor >= (hora_que_enviou_a_primeira_ordem+intervalo_segundos)) {
    n_ordens_enviadas = 0;
    hora_que_enviou_a_primeira_ordem = 0;
    marcou_hora_primeira_ordem = false;
    }
    
    if (n_ordens_enviadas >= n_maximo_ordens_enviadas_em_x_segundos) {
      FecharPosicaoAbertas();
      FecharOrdensPendentesCompraDoAtivo();
      FecharOrdensPendentesVendaDoAtivo();
      FecharOrdensPendentesBuyStopAtivo();
      FecharOrdensPendentesSellStopAtivo();
      FecharPosicaoAbertas();
      Print("ROBÔ FECHADO - ENVIO MASSIVO DE ORDENS - ProtecaoEnvioMassivoOrdens()");
      ExpertRemove();
    }
  
  }

  return true;
}


//void  CriaLinhaATRMinimoDeAlta()
//{
// //CRIA LINHA ATR MINIMO DE ALTA
//
//   datetime criaLinhaATRMinimoDeAlta = iTime(_Symbol,PERIOD_CURRENT,0);
//   ObjectCreate(
//                0,                                             // ID de gráfico
//                "linhaATRMinimoDeAlta",                        // Nome da linha
//                OBJ_HLINE,                                     // Tipo da linha
//                0,                                             // Sub Window
//                criaLinhaATRMinimoDeAlta,                      // Datetime do objeto         
//                precoDaLinhaATRAlta          // Preço
//                );
//                
//   ObjectSetInteger(0,"linhaATRMinimoDeAlta",OBJPROP_STYLE,STYLE_DOT);
//   ObjectSetInteger(0,"linhaATRMinimoDeAlta",OBJPROP_COLOR,clrGray);
   

void  CriaLinhaATRMinimoDeAltaEBaixa()
{
   CopyRates(_Symbol,PERIOD_M5,0,114,candles5);
   CopyRates(_Symbol,PERIOD_D1,0,2,candlesDia);
 
   for(int i=0; i<114; i++)
     {
     if(TimeToString(candles5[i].time, TIME_DATE) == TimeToString(candlesDia[0].time, TIME_DATE))
       {
       barra5DeOntemHIGH = candles5[i].high;
       barra5DeOntemLOW = candles5[i].low;
       chaveDiaOntem = candlesDia[0].time;
       //CRIA LINHA DE ALTA
          ObjectCreate(0, "linhaHigh", OBJ_TREND,0,primeiroCandle5Horario,precoDaLinhaATRAlta,tick.time,precoDaLinhaATRAlta); 
          ObjectSetInteger(0,"linhaHigh", OBJPROP_COLOR,clrYellow);
          ObjectSetInteger(0,"linhaHigh",OBJPROP_STYLE,STYLE_DOT);
          ObjectSetInteger (0, "linhaHigh", OBJPROP_RAY_RIGHT,false);   
          
       //CRIA LINHA DE BAIXA
          ObjectCreate(0, "linhaLow", OBJ_TREND,0,primeiroCandle5Horario,precoDaLinhaATRBaixa,tick.time,precoDaLinhaATRBaixa);
          ObjectSetInteger(0,"linhaLow", OBJPROP_COLOR,clrYellow);
          ObjectSetInteger (0, "linhaLow", OBJPROP_RAY_RIGHT,false);  
          ObjectSetInteger(0,"linhaLow",OBJPROP_STYLE,STYLE_DOT);                          
       }
     }

}


bool ControleDeAcesso(string nome_cadastrado, long conta_real_producao, long conta_demo, int numero_maximo_contratos, int dia, int mes, int ano) {

  
  datetime dataAtt = TimeCurrent();
  string data_completa = "";
  long numero_da_conta_real = AccountInfoInteger(ACCOUNT_LOGIN);
  string nome_do_usuario_na_corretora = AccountInfoString(ACCOUNT_NAME);
  string nome_backtest = "Tester";
  
  //aqui faz a conversao da data caso o usuário esqueça de digitar um "0" antes....
  if (((dia == 1) || (dia == 2 ) || (dia == 3 ) || (dia == 4) || (dia == 5) || (dia == 6) || (dia == 7) || (dia == 8) || (dia == 9)) && ((mes != 1) && (mes != 2) && (mes != 3) && (mes != 4) && (mes != 5) && (mes != 6) && (mes != 7) && (mes != 8) && (mes != 9))) {
    data_completa = (string)ano + "." + (string)mes + ".0" + (string)dia + " 00:00";
  } else if (((dia != 1) && (dia != 2 ) && (dia != 3 ) && (dia != 4) && (dia != 5) && (dia != 6) && (dia != 7) && (dia != 8) && (dia != 9)) && ((mes == 1) || (mes == 2) || (mes == 3) || (mes == 4) || (mes == 5) || (mes == 6) || (mes == 7) || (mes == 8) || (mes == 9))) {
    data_completa = (string)ano + ".0" + (string)mes + "." + (string)dia + " 00:00";
  } else if (((dia == 1) || (dia == 2 ) || (dia == 3 ) || (dia == 4) || (dia == 5) || (dia == 6) || (dia == 7) || (dia == 8) || (dia == 9)) && ((mes == 1) || (mes == 2) || (mes == 3) || (mes == 4) || (mes == 5) || (mes == 6) || (mes == 7) || (mes == 8) || (mes == 9))) {
    data_completa = (string)ano + ".0" + (string)mes + ".0" + (string)dia + " 00:00";
  } else {
    data_completa = (string)ano + "." + (string)mes + "." + (string)dia + " 00:00";
  }


  datetime vencimentoRobo = StringToTime(data_completa);
  //if (tipoConta == ACCOUNT_TRADE_MODE_DEMO) vencimentoRobo = D'2030.01.01 00:00'; //se o robô é conta demo.. entao vence numa data futura bem pra frente.. a pessoa pode usar...
  //Print("Data Atual = ", dataAtt);
  //Print("Data Vencimento Robo = ", vencimentoRobo);
  //Print("A data atual chegou no vencimento? = ", (dataAtt >= vencimentoRobo));

  if (dataAtt >= vencimentoRobo) {
  Print("Prazo de Validade Vencido, Favor Contactar o Administrador");
  ExpertRemove();
  return false;

  } 
    
  if ((nome_cadastrado != "") && (nome_cadastrado != nome_do_usuario_na_corretora) && (nome_backtest != nome_do_usuario_na_corretora)) {  //PARA HABILITAR BACKTEST
  //if ((nome_cadastrado != "") && (nome_cadastrado != nome_do_usuario_na_corretora)) { //PARA DESABILITAR BACKTEST
  Print("O nome do usuário na corretora não é o mesmo da licença do robô. Favor contactar o Administrador!");
  Print("O nome do usuário dono da licença é " + NOME_NA_CORRETORA + ", e você quer logar com a conta cujo titular é " + nome_do_usuario_na_corretora + ".");
  Print("----------");
  ExpertRemove();
  return false;
  }
  
  //aqui faz o controle pelo numero de contratos...
  if ((tipoConta == ACCOUNT_TRADE_MODE_REAL) && (quantidadeContratos > numero_maximo_contratos)) {
  Print("Você não pode operar " + (string)quantidadeContratos + " contratos, precisamos de liquidez para todo mundo.. Por favor, diminua para até " + (string)numero_maximo_contratos + " contratos.");
  Print("Se estiver utilizando BackTest... FAÇA EM CONTA DEMO!!!.");
  ExpertRemove();
  return false;

  }
  
  
  //aqui faz o controle pelo numero da conta...
  if ((tipoConta == ACCOUNT_TRADE_MODE_REAL) && (numero_da_conta_real != conta_real_producao)) {
  Print("Essa conta NÃO está habilitada para operar no ambiente real. Contate o pessoal da @ Gestão Trader...");
  Print("Essa conta NÃO está habilitada para operar no ambiente real. Contate o pessoal da @ Gestão Trader...");
  ExpertRemove();
  return false;

  }
  
  //aqui faz o controle pelo numero da conta...
  if ((tipoConta == ACCOUNT_TRADE_MODE_DEMO) && (numero_da_conta_real != conta_demo)) {
  Print("Essa conta NÃO está habilitada para operar. Contate o pessoal da @ Gestão Trader...");
  Print("Essa conta NÃO está habilitada para operar. Contate o pessoal da @ Gestão Trader...");
  ExpertRemove();
  return false;

  }
    
    return true;
}