I will provide you  an EA which works in meta trader 5
//+------------------------------------------------------------------+
//|                                                      ProjectName |
//|                                      Copyright 2020, CompanyName |
//|                                       http://www.companyname.net |
//+------------------------------------------------------------------+

#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Trade/Trade.mqh>

CTrade         trade;
CPositionInfo  pos;
COrderInfo     ord; 

input group  "=== Trading  Inputs ==="

      input double        RiskPercent  =  3;
      input int           Tppoints     =  200;
      input  int           Slpoints    =  200;
      input int       TslTriggerPoints = 15;
      input int            Tslpoints   = 10;
      input ENUM_TIMEFRAMES  Timeframe = PERIOD_CURRENT;
      input int            InpMagic    = 298347;
      input string         TradeComment = "Scalping Robot";
      
      enum StartHour  {Inactive=0, _0100=1, _0300=3, _0400=4, _0500=5, _0600=6, _0700=7, _0800=8, _0900=9, _1000=10, _1100=11, _1200=12, _1300=13, _1400=14, _1500=15, _1600=16, _1700=17, _1800=18, _1900=19, _2000=20, _2100=21, _2200=22, _2300=23 };
      
      
      input StartHour SHInput =0;
      
      enum EndtHour  {Inactive=0, _0100=1, _0300=3, _0400=4, _0500=5, _0600=6, _0700=7, _0800=8, _0900=9, _1000=10, _1100=11, _1200=12, _1300=13, _1400=14, _1500=15, _1600=16, _1700=17, _1800=18, _1900=19, _2000=20, _2100=21, _2200=22, _2300=23 };
      
      input EndtHour EHInput=0;
      
      int SHchoice;
      int EHchoice;
      
      int            BarsN = 5;
      int            ExpirationBars = 100;
      int            OrderDistPoints = 100;
 

int OnInit()
  {
  trade.SetExpertMagicNumber(InpMagic);
   ChartSetInteger(0, CHART_SHOW_GRID, false);

   return(INIT_SUCCEEDED);
  }


void OnDeinit(const int reason)
  {


  }
void OnTick(){

      TrailStop();   
      if(!IsNewBar()) return;
      
      MqlDateTime time;
      TimeToStruct(TimeCurrent(),time);
      int Hournow = time.hour;
      
      SHchoice = SHInput;
      EHchoice = EHInput;
      
      if(Hournow<SHchoice){ CloseAllOrders(); return;}
      if(Hournow>=EHchoice && EHchoice!=0){ CloseAllOrders(); return;}   
      
      int BuyTotal = 0;
      int SellTotal = 0;
      
      
      for(int i=PositionsTotal()-1; i>=0; i--){
         
         pos.SelectByIndex(i);
         if(pos.PositionType()==POSITION_TYPE_BUY && pos.Symbol() == _Symbol && pos.Magic()==InpMagic)  BuyTotal++;
         if(pos.PositionType()==POSITION_TYPE_SELL && pos.Symbol() == _Symbol && pos.Magic()==InpMagic) SellTotal++;
       }
      
      
      
      for(int i=OrdersTotal()-1; i>=0; i--){
         
         ord.SelectByIndex(i);
         if(ord.OrderType()==ORDER_TYPE_BUY_STOP && ord.Symbol() == _Symbol && ord.Magic()==InpMagic)  BuyTotal++;
         if(ord.OrderType()==ORDER_TYPE_SELL_STOP && ord.Symbol() == _Symbol && ord.Magic()==InpMagic) SellTotal++;
      
      
      } 
      
      if(BuyTotal<=0){
      double high = findHigh();
      if(high >0){
         SendBuyOrder(high);
         }
     }
       if(SellTotal<=0){
      double low = findlow();
      if(low >0){
         SendSellOrder(low);
         }
     }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double findHigh()
  {

   double highestHigh = 0;

   for(int i=0; i < 200;i++)
     {
      double high = iHigh(_Symbol,Timeframe,i);
      if(i  > BarsN && iHighest(_Symbol, Timeframe, MODE_HIGH,BarsN*2+1,i-BarsN) == i)
        {
         if(high > highestHigh)
           {
            return high;
           }
        }
      highestHigh = MathMax(high,highestHigh);
     }
   return -1;
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double findlow()
  {

   double lowestLow  = DBL_MAX;

   for(int i=0; i < 200;i++)
     {
      double low = iLow(_Symbol,Timeframe,i);
      if(i  > BarsN && iLowest(_Symbol, Timeframe, MODE_HIGH,BarsN*2+1,i-5) == i)
        {
         if(low < lowestLow)
           {
            return low;
           }
        }
      lowestLow = MathMin(low,lowestLow);
     }
   return -1;
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsNewBar()
  {
   static datetime previousTime = 0;
   datetime currentTime = iTime(_Symbol, Timeframe,0);
   if(previousTime!=currentTime)
     {
      previousTime = currentTime;
      return true;
     }
   return false;
  }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SendBuyOrder(double entry)
  {
   double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);

   if(ask > entry - OrderDistPoints * _Point)
      return;

   double tp = entry + Tppoints * _Point;
   double sl = entry - Slpoints * _Point;
   
   double lots = 0.01;
   if(RiskPercent >0)lots = calcLots(entry - sl);
   
   datetime expiration = iTime(_Symbol,Timeframe,0) + ExpirationBars * PeriodSeconds(Timeframe);
    
    trade.BuyStop(lots,entry,_Symbol,sl,tp,ORDER_TIME_SPECIFIED,expiration);     
  }




void SendSellOrder(double entry)
  {

   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);

   if(bid < entry + OrderDistPoints * _Point)
      return;

   double tp = entry - Tppoints * _Point;
   double sl = entry + Slpoints * _Point;
   
   double lots = 0.01;
   if(RiskPercent >0)lots = calcLots(sl - entry);
   
   datetime expiration = iTime(_Symbol,Timeframe,0) + ExpirationBars * PeriodSeconds(Timeframe);
    
    trade.SellStop(lots,entry,_Symbol,sl,tp,ORDER_TIME_SPECIFIED,expiration);
    
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double calcLots(double slPoints)
  {

   double risk = AccountInfoDouble(ACCOUNT_BALANCE) * RiskPercent / 100;

   double ticksize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double tickvalue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double lotstep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double minvolume=SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN);
   double maxvolume = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX);
   double volumelimit = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_LIMIT);

   double moneyPerLotstep = slPoints / ticksize * tickvalue * lotstep;
   double lots = MathFloor(risk / moneyPerLotstep) * lotstep;

   if(volumelimit!=0)
      lots = MathMin(lots, volumelimit);
   if(maxvolume!=0)
      lots = MathMin(lots, SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX));
   if(minvolume!=0)
      lots = MathMax(lots, SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN));
   lots = NormalizeDouble(lots,2);

   return lots;
  }
  
  
void CloseAllOrders(){

   for(int i=OrdersTotal()-1;i>0;i--){
      ord.SelectByIndex(i);
      ulong ticket = ord.Ticket();
      if(ord.Symbol() == _Symbol && ord.Magic() == InpMagic){
         trade.OrderDelete(ticket);
      }
   
   }

}

void TrailStop(){
   
      double sl=0;
      double tp=0;
      
      double ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
      
      for ( int i = PositionsTotal()-1;i>=0;i--){
         if(pos.SelectByIndex(i)){
            ulong Ticket = pos.Ticket();
               
               if(pos.Magic()==InpMagic && pos.Symbol()==_Symbol){
               
                  if (pos.PositionType() == POSITION_TYPE_BUY){           
                     if(bid-pos.PriceOpen()>TslTriggerPoints*_Point){
                        tp = pos.TakeProfit();
                        sl = bid- (Tslpoints * _Point);
                        
                        if(sl> pos.StopLoss() && sl!=0){
                           trade.PositionModify(Ticket,sl,tp);                                 
                  }
               }
            }
             else if (pos.PositionType() == POSITION_TYPE_SELL){
                     if(ask+(TslTriggerPoints*_Point)<pos.PriceOpen()){
                        tp = pos.TakeProfit();
                        sl = ask + (Tslpoints * _Point);
                        
                        if(sl < pos.StopLoss() && sl!=0){
                         trade.PositionModify(Ticket,sl,tp);                                
                     }
                  }                            
               }
            }    
         }
      }
   }

now do the following
Begin a theoretical backtest of the EA (Expert Advisor) using real tick data sourced from one of the following providers: Tickstory, Quant DataManager, Tick Data Suite. This analysis will occur over the period of 1st January 2025 to 20th June 2025, focusing on the currency pairs XAUUSD and EURUSD.

Objective:
- Optimize input settings to make the EA profitable and enable it to meet the Stellar One challenge of FundedNext.
- Implement and utilize a 200 EMA filter within the analysis, without adding any additional indicators or filters.

Backtesting Specifications:
- Perform tests on different time frames: 5-minute, 15-minute, 1-hour, and 4-hour charts.
- Optimize input settings according to each time frame and compile the best inputs for every time frame.
- Calculate and provide the win rate, net profit, and Sharpe ratio for each optimized setting.

Process outline:
Step 1 - Acquire real tick data from the specified providers for the backtest duration.
Step 2 - Implement the 200 EMA filter in the EA code for analysis.
Step 3 - Perform theoretical backtests on XAUUSD and EURUSD for each specified time frame.
Step 4 - Experiment with various input settings to optimize the EA.
Step 5 - Compile results including best inputs, win rate, net profit, and Sharpe ratio for each time frame.

Based on this framework, please proceed with querying data, testing settings, analyzing results, and iterating optimizations as needed.