• 미리보기
  • 리뷰
  • 코멘트 (5)
  • 새 소식

Orion Intelligence System

Trading Signal:

High Risk : Click Here Low Risk : Click Here

Rental and Pricing:

The current price of the Orion is $600 USD. Soon, the price will increase to $5,600 USD, so take advantage of the current pricing while it lasts.

Orion Intelligence System Overview:

The Orion Intelligence System integrates multiple indicators and semi-AI technology for automated trading. It identifies harmonic patterns, support, and resistance levels to determine trade execution, utilizing a martingale strategy when appropriate and confirmed by indicators.

  • Pattern Detection: Identifies harmonic patterns and support/resistance levels.
  • Drawdown Control: Mechanisms to manage and minimize drawdowns, protecting trading capital.
  • AI in Technical Indicators: Uses AI-enhanced technical indicators for live trading analysis.
  • Indicator Alignment: Ensures multiple indicators align before making trading decisions.
  • Support and Resistance: Identifies strong Support and Resistance levels for accurate trading decisions.
  • Risk Money Management (Auto MM): Adjusts position sizes based on equity and risk tolerance.

Recommended Settings:

  • Timeframe: M15
  • Base currency pairs: AUDCAD, AUDNZD, NZDCAD
Minimum Capital: $100 to $10,000 (Higher capital increases profit potential)

      Easy Setup:

      • Attach the EA to the M15 charts for AUDCAD, AUDCHF.
      • Use settings: 1000 for high risk or 2000 for low risk.
      • Recommended leverage: 1:500.
      • Use a low spread account (e.g., Exness).

      Performance:

      • Drawdown: Backtests show a maximum of 45% for high risk and 25% for low risk.

      Installation:

      • Simple installation with minimal input parameters.
      • Restart MT4 three times for optimal performance.

      Final Notes:

      • Be patient for trades to occur.
      • Avoid using other EAs simultaneously.
      Could you please add me to my business Facebook account? My FB link: fb.com/business-profile
      추천 제품
      The Expert Advisor identifies the most probable direction of the price based on the divergence of volumes and consolidation of prices in the overbought/oversold areas. Filtering for opening trades is carried out by using a unique formula for calculating the price level - "magnet" (based on the Ichimoku indicator), where the price is highly probable to come within a few bars in the future. The EA contains a minimum of settings, which facilitates its usage. Recommended symbols: EURUSD 15m ; GBPUSD
      Check out my LIVE channel to see this EA in profitable action! Check My Profile. Or Check out a video of this EA in the screenshot section at the bottom of this page. Recover your MOST PRECIOUS assets: TIME and PEACE of MIND . Set-and-Forget, Plug-and-Play, autonomous, multifunction, DayTrading EA.    BING DayTrading Pro is a fully autonomous, intervention-free, day trading EA. Designed to take Low-Risk, High Win rate, Low DD trades, with advanced trade management, during the trading day. N
      CapTaiNCAT
      Nyamsuren Boldbaatar
      CapTaiNCAT FullAutomated expert advisor. TimeFrame M1 M5 SET FILES;   https://www.mql5.com/en/market/product/38300#!tab=comments&comment=11565247 Recommendations Before using the EA on a real account, test it with minimal risk or on a demo account; Use VPS server with ping less 10ms; ECN account with low spreads + low commissions + quality execution;  Standard settings are optimized for EURUSD GBPUSD AUDUSD USDCAD USDJPY USDCHF XAUUSD  The settings of the EA  Trade Manager  
      Robo GBPUSD
      Nguyen Hang Hai Ha
      Expert Advisor Robo GBPUSD is programmed specifically for the GBPUSD market with advanced and advanced algorithms. Similar to EA Robo Gold, this EA's strategy applies volatility analysis techniques and price tick models, correlating oscillation frequencies to search for reliable trading signals with high probability. Trading orders always have Stop Loss and Take Profit available, along with a Trailing feature optimized for scalper style to quickly exit the market with low risk. Robo GBPUSD has b
      Analitic RSI
      Yvan Musatov
      A professional expert analyzes the market using the relative strength index. The basic principle is that the bot takes the indicated prices for a certain period of time and calculates the strength and amplitude of the price. This can show when the trend will lose strength and reverse. The signal from the exit from the overbought/oversold zones is analyzed, the levels of these zones will be the levels with LEVEL_MAX and LEVEL_MIN values. We buy when the signal first falls below a certain level (
      Night Cat
      Denis Bogdanov
      Fully automated trading system. Advisor in its algorithm uses the regularities of the market. The price movement in the channel in certain time intervals. The system uses: Defining price ranges. Calculation of volatility of currency pairs for signal confirmation. Dynamic closing levels. Spread and slippage filter. Dynamic calculation of the position volume depending on the current deposit (optional) Recommended currency pairs: EURUSD,GBPUSD,AUDUSD,AUDCAD,GBPCAD,GBPNZD,GBPAUD,EURNZD Before i
      InvestorPRO
      Andrey Spiridonov
      InvestorPRO is a stable Expert Advisor for professional traders. The EA trades in a fully automated mode. The trading algorithm of the EA is based on analysis of numerous factors that affect the dynamics of an instrument. This EA has been created to provide the trader with a comfortable environment for investment in the financial instruments of the Forex market. The EA is installed in the usual way and is suitable for trading any trading symbols. The EA is designed for trading on the D1 timefra
      Peregrine Scalper EA
      Cutting Edge Forex LLC
      5 (1)
      Sophisticated   cutting edge algorithms are the heart of this professional fully automated trading system. Unique ability to identify key supply and demand areas using our in-house sophisticated "Time Strength" algorithm that calculates how strong supply and demand areas are as they move into the past. The areas with the highest likelihood for profitable scalping are identified and traded. Coded by professionals with over 12 years trading and system development for professional traders and hedge
      Bfxenterprise RSI
      Ricky Romadona Tri Saputra
      Bfxenterprise RSI Inspired and optimized RSI indicator is the focus of this Expert Advisor (EA). Designed with the use of RSI to perform optimal transactions. Reading trends and price reversals is done by the RSI whose functions have been sorted. Version of Bfxenterprise The version with the name “Bfxenterprise” focuses on special and thorough sorting of transactions. So this version does not always make transactions, unlike the Expert Advisor version in general. This version relies on accuracy
      Civilization Trio
      Tran Thi Thu Huyen
      5 (3)
      Civilization Trio is a high frequency trading expert advisor (EA/bot). EA is designed to overcome the challenges of proprietary trading companies (support companies). Basically, it is designed for currency pairs, especially EURUSD. You can pass the FTMO challenge within 1 month. *** Buy Civilization trio robot and message me to get more Civilization trio pro unlimited edition PREFERENTIAL PURCHASE PRICE: Only 10 copies left at current price! Final price: $2500 LIVE SIGNAL --------------------
      Arda
      Evgeniy Zhdan
      2 copy of 10 left at this price.  Next 10 copies $549. Arda is a trading Expert Advisor based on the dissonance of technical indicators  and price patterns. Support: https://www.mql5.com/en/channels/TrendHunter The Expert Advisor was tested on real historical data of EURUSD, GBPUSD and XAUUSD (Gold). You can download a demo version of any program (for example, tickstory - there is a free version) that provides quotes with 99.9% quality and check it yourself. The trading strategy does not co
      5 Units left at 900 USD. Next price 1200 USD This expert advisors search for perfect impulse setups. The approach is use a very few but high effectives rules / filters and an effective management of the opened position. Signal https://www.mql5.com/es/signals/2049326 Backtest The EA must be backtest in any timeframe, but for use in live, must be attached to a M5 chart. Live setup The EA is very easy to configure, and can be used with the default parameters. Only the parameters r
      Voluntas  is the advanced Martingale-  G rid System   which already works. It was designed to exploit existing market inefficiencies. Instead it uses real market mechanics to its advantage to make profit. All costs (Commission & Swap) are included in the Trades. Only 1/2  copies  of the EA left  at $149! Next price -->  $199 Supported currency pairs:  AUDCAD, AUDNZD, NZDCAD Recommended Timeframe:   M15 UPDATES:  09.10.2022 16:26   User friendly attitude Features: Multiple  C urrency Pairs Supp
      Forest
      Vadim Podoprigora
      Forest is a Trend Expert Advisor based on the analysis of a unique mathematical model of trend lines, which allows you to determine the trend movement. The Expert Advisor is most suitable for the currency pair "USDCHF" on period "H1". The EA can work on any type of accounts, and with any brokers. The EA uses mathematical analysis to open trades and applies loss control to open trades. At its core, the EA does not use any risky systems with the increase in the volume or increase in the number of
      Works to open two hedging deals, buying and selling, with a goal of each deal of 20 points With the opening of multiple cooling deals in the manner of another lot size and suspending each type of sale or purchase transaction At a profit level. Parameters: Lot1: Manual Lot Size Auto_Lot: Set true to automatically calculate optimal Lot Size based on risk preferences, Set False if you want use manual lot size. Max_Risk: Max Risk as percentage of Equity* the greater this percentage is the great
      Octopus Stability
      Aleksandr Shurgin
      After a thorough work and search for the optimal values of each of the Expert Advisor's parameters, the most stable settings of the algorithms have been selected, which do not require over large history periods. The robot uses a universal trading strategy, allowing the use of the currency pairs EURUSD, GBPUSD, USDCHF, USDJPY and other pairs with low spread. The EA trades on a 5-minute timeframe , it uses levels defined automatically on the bases of multiple parallel price movement calculation me
      EAalgotrading
      Francesco Lippo
      This trading bot is based on the Supply and Demand strategy, which is one of the most popular strategies in technical analysis for financial markets like Forex, used to identify key areas of support and resistance. Here are the fundamental principles and how the bot works:  "It works excellently on Nat Gas with a 30-minute timeframe and a minimum capital of 1,600 euros. Fundamental Principles of the Supply and Demand Strategy: Demand Zones : These are areas on price charts where the demand for
      Jet Punch
      Didit Haryadi Saputra
      Jet Punch is another best expert advisor for MT4,  can help you make money while you sleep by automatically entering and exiting trades. It trades by opening trades every day and closing them at the right time to ensure you always earn a profit. The software is very simple and can be used by both beginner and experienced traders.  Jet Punch was tested and has successfully passed the stress test with slippage and commission approximate to the real market condition. Recommendations: Currency pair
      VolnaFX
      Roman Meskhidze
      4.76 (21)
      LAUNCH PROMO Next price:        $349 The price will be rise to limit the number of users for this strategy The "Volna FX" Expert Advisor is a representative of robots trading from levels. Levels can be built automatically, or they can be rigidly set in the parameters of the Expert Advisor. CHECK REAL SIGNAL :  https://www.mql5.com/en/signals/847709 The uniqueness of the advisor is that it can work both with averaging and using the martingale principle, or without it, i.e. use a clear take profi
      Sonata MT4
      Evgeniy Zhdan
      The Expert Advisor's strategy is based on proactive forecasting of the most likely price movement. The method for determining this movement is the calculation and ratio of such factors as: short-term OHLC candlestick patterns, the direction of the microtrend, the rate of price change. Only 1 deal on one trading instrument can be opened at a time. Support:   https://www.mql5.com/en/channels/TrendHunter No hazardous trading methods are used. The Expert Advisor has minimal settings, which al
      Scalper Gold Reborn
      Zahidin Zainal Zulkornain
      Scalper Gold Reborn is an Expert Advisor designed specifically for trading gold but can use at currency too. The operation is based on opening orders using the Bolinger Band and Moving Average . Monitoring Live Signal: https://www.mql5.com/en/signals/1805669 Recommendations Timeframe : M1 Pairs : GOLD/Currencies Settings: Default Lot : Use 0.01 for every 10.000cents Leverage: 1:1000 or higher Contact me in private for more setfiles. Setup Open M1 timeframe charts for pair GOLD or currency. At
      TWZ Gold Killer
      Zafar Iqbal Sheraslam
      The Gold Killer support and resistance strategy with Trilling Stop loss is a trading method that focuses on identifying key levels where the price of gold tends to find support (stop falling) and resistance (stop rising). Here's a breakdown of how to apply this strategy effectively: Best Time Frame: 01 Hour Works only on Gold: Minimum Deposit 10K If someone wants for Currencies DM Me. 1. Understanding Support and Resistance Support Level: A price level where a downtrend can be expected to pause
      QuatronPro
      Marek Kvarda
      This robot is designed for major currency pairs and trades several strategies: swings, gaps and SR levels. It uses an advanced algorithm for analyzing price data and looks for the best parameters. Trading signals are filtered by results of analysis of daily and monthly chart for the last 12 periods. It is built on the foundations of the successful EA Triton . This is not a scalping robot. It is not sensitive to spread and slip. It will be traded at all brokers with quotation accurate to point
      Forex Bulls Gold VIP
      Hossein Davarynejad
      //// Forex Bulls  GOLD  VIP //// Introducing Forex Bulls Gold VIP  :  the cutting-edge Gold  development expert meticulously crafted for daily time frame strategies with an integrated stop-loss mechanism. As the developer behind this powerful tool, let me delve into the key features and advantages that make  Bulls Gold  a must-have for your daily Gold trading endeavors: . Daily Time Frame Precision: Forex Bulls Gold VIP  is tailored to excel in the   daily   time frame, ensuring optimal precis
      Hercules Gold VIP
      Hossein Davarynejad
      5 (1)
      *     MT5 Version is free  + one Daily Trader on BTC USD is free  * 37 WEEK LIVE RESULT                               Live Signal =  signal      //// HERCULES GOLD VIP //// the cutting-edge Gold  development expert meticulously crafted for daily time frame strategies with an integrated stop-loss mechanism. As the developer behind this powerful tool, let me delve into the key features and advantages that make   a must-have for your daily Gold trading endeavors: . Daily Time Frame Precision: H
      EA works with none of the technical indicators.   It waits for the trend and trade accordingly. No standard indicators. No grid trading. No arbitrage. No curve fitting according to back-test results No Hedge   Very low Stop Loss Ratio  Tested with 99.90% data Modelling quality. Can work with even $30 USD Recommendations : Developed for M1, EURUSD ECN Broker with 5 points Settings Spread: Need to be as low as possible. Trailing Status: trailing stop usage option Trailing stop: Pips to allow trail
      Unusual EA
      Khairudi Kherikhanov
      Автоматический советник Unusual EA не предназначен для получения сверх прибыли. Больше подойдет долгосрочным инвесторам, для которых трейдинг не игра, а работа. Советник Unusual EA, также можно использовать в портфеле, совместно с другими советниками. Размер прибыли и просадки зависит от выбранной валютной пары и таймфрейма.Наиболее эффективен на периодах M30,H1 и H4, хотя может использоваться на любых таймфреймах и торговых инструментах. Параметры советника: MagicNumber- метка "своих" с
      Millennium EA
      Vladimir Pleshakov
      The scientific approach to trading and responsible development are the main principles of  Millennium  EA. In order to create this EA, a research work was done in the field of trading. Dow theory, the theory of fractal analysis, the methods of Bill Williams and other traders, all this served as the theoretical basis for the advisor, which is designed to automate trading decisions. Signals: https://www.mql5.com/en/signals/1748354 https://www.mql5.com/en/signals/1748359 https://www.mql5.com/en/sig
      The MelBar HedgeScalper FinTech RoboTrader MAXIMUM LOTSIZE : 100 Lots (US$10,000,000) per TRADE/POSITION FULLY TRIED, TESTED, PROVEN & VERIFIED ON A REAL LIVE TRADING ACCOUNT! TRY OUT THE DEMO! The Experienced Trader & Global Money Manager Version. 89% Trade Winning Percentage. 32.679% Profit Gain or ROI in 2 Trading Days. Profit Factor 3.59 Average Trade Length 1h 22m. The MelBar HedgeScalper FinTech RoboTrader is easy to use. Has the Advantage of Retiring Unnecessary "Debt
      Rapture
      Evgeniy Zhdan
      The automated trading system is developed based on the "Comfort Range" theory. According to this theory, the chart of each trading instrument has its own dynamically changing range of movement. The skill of determining such a range allows you to use this information as a leading indicator and predict price movement in the near future. The Rapture Expert Advisor determines the "Comfort Range" of the trading instrument and works in the direction of the expected future movement. The EA does
      이 제품의 구매자들이 또한 구매함
      Ai Hybrid Robot MT4
      Mansour Babasafary
      5 (3)
      Several experts in one expert With this expert, you can use several up-to-date strategies Enhanced with artificial intelligence Can be used in several popular forex currencies Can be used in the most popular forex time frames Without using high-risk strategies Attributes : Can be used in the EURUSD , GBPUSD , USDCHF , AUDUSD , USDCAD , NZDUSD  currency pairs Can be used in M30 , H1 , H4 , D1 time frames Has profit limit and loss limit Without using risky strategies like martingale or hedg
      Big Forex Players MT4
      Marzena Maria Szmit
      4.71 (28)
      We proudly present our cutting-edge robot, the  Big Forex Players EA  designed to maximize your trading potential, minimize emotional trading, and make smarter decisions powered by cutting-edge technology. The whole system in this EA took us many months to build, and then we spent a lot of time testing it. This unique EA includes three distinct strategies that can be used independently or in together. The robot receives the positions of the   biggest Banks   (p ositions are sent from our databa
      Magnat
      Alexander Buseinus
      A professional Expert Advisor designed for trading any instrument of the Metatrader 4 platform. Work Features: A large number of input parameters, with a wide range of settings, allow you to work on all instruments with any broker trading conditions. Depending on trading conditions, it can work with direct market positions or dynamic pending orders. When switching the corresponding input parameter, the Expert Advisor always opens only one trading position at a time, or it can open many posit
      Silicon Ex
      Nadiya Mirosh
      " Silicon Ex ": Your Reliable Assistant in the World of Forex Silicon Ex is a modern trading bot, specially created for traders in the Forex market. This innovative tool serves as a reliable partner for those who strive for efficient and automated trading. Key Features of "Silicon Ex": Reliability and Stability: Created using advanced technologies that ensure stable and reliable operation in the market. Intelligent Risk Management: Built-in money management system (Money Management) allows yo
      The Expert Advisor works on the basis of wave-like changes in price movements. The dynamic regression channel allows you to accurately predict the price movement in the short term. The Expert Advisor uses the indicator in its trading: https://www.mql5.com/en/market/product/64252 Trading instruments (TF 5m): GBPUSD, EURUSD, USDJPY. The Expert Advisor has been successfully tested with 99% quality quotes, floating spread and random ping since 2003. Optimization of the advisor is not requir
      AI Nodiurnal EA
      Ugochukwu Mobi
      AI Nodiurnal EA는 최첨단 기계 학습 기술을 활용하여 거래 전략을 최적화하고 동적인 외환 시장에서 성능을 향상시키는 고급 Forex 로봇입니다. "Nodiurnal"이라는 용어는 전형적인 주간 거래 시간뿐만 아니라 비표준 기간 동안에도 적응하고 작동하는 능력을 반영하여 외환 거래에 대한 지속적이고 적응적인 접근을 제공합니다. 설정: 통화 쌍의 기본 설정: EURUSD H1. 특별 설정은 구매 후에만 제공됩니다. 실제 신호 계정은 여기에 있습니다:   https://www.mql5.com/ko/signals/1270367 MT5 버전은 여기에 있습니다:   https://www.mql5.com/ko/market/product/ 74716 마켓 론칭 프로모션! USD 5,500에 10개 중 10개만 남았습니다. 다음 가격: USD 7,500 최종 가격: USD 10,000 주요 특징: 기계 학습 알고리즘: AI Nodiurnal EA의 핵심 강점은 기계 학습 알고리즘의 활용에
      Aura Black Edition
      Stanislav Tomilov
      4.59 (17)
      Aura Black Edition is a fully automated EA designed to trade GOLD only. Expert showed stable results on XAUUSD in 2011-2020 period. No dangerous methods of money management used, no martingale, no grid or scalp. Suitable for any broker conditions. EA trained with a multilayer perceptron Neural Network (MLP) is a class of feedforward artificial neural network (ANN). The term MLP is used ambiguously, sometimes loosely to any feedforward ANN, sometimes strictly to refer to networks composed of mult
      Waka Waka EA
      Valeriia Mishchenko
      4.34 (50)
      EA has a live track record with 4.5 years of stable trading with low drawdown: Live performance MT5 version can be found here Waka Waka is the advanced grid system which already works on real accounts for years. Instead of fitting the system to reflect historical data (like most people do) it was designed to exploit existing market inefficiencies. Therefore it is not a simple "hit and miss" system which only survives by using grid. Instead it uses real market mechanics to its advantage to make p
      Btcusd Grid
      Ahmad Aan Isnain Shofwan
      BTCUSD GRID EA는 그리드 거래 전략을 사용하도록 설계된 자동화된 프로그램입니다. BTCUSD GRID EA는 초보자와 숙련된 거래자 모두에게 매우 유용합니다.   사용할 수 있는 다른 유형의 거래 봇이 있지만 그리드 거래 전략의 논리적 특성으로 인해 암호화폐 그리드 거래 봇이 문제 없이 자동화된 거래를 쉽게 수행할 수 있습니다.   BTCUSD GRID EA는 그리드 거래 봇을 시험해 보고자 하는 경우 사용할 수 있는 최고의 플랫폼입니다. BTCUSD GRID EA는 통화 변동성이 큰 경우에도 이상적인 가격 지점에서 자동 거래를 수행할 수 있기 때문에 암호화폐 산업에 매우 효과적입니다.   이 자동 거래 전략의 주요 목적은 EA 내에서 미리 설정된 가격 변동에 따라 수많은 매수 및 매도 주문을 하는 것입니다.   이 특별한 전략은 자동화하기 쉬우므로 일반적으로 암호화폐 거래에 사용됩니다.   그리드 트레이딩 전략을 올바르게 사용하면 자산 가격이 변할 때 돈을 벌 수
      Bonnitta EA
      Ugochukwu Mobi
      3.5 (20)
      Bonnitta EA는 보류 포지션 전략(PPS)과 매우 진보된 비밀 거래 알고리즘을 기반으로 합니다. Bonnitta EA의 전략은 비밀 사용자 지정 지표, 추세선, 지원 및 저항 수준(가격 조치) 및 위에서 언급한 가장 중요한 비밀 거래 알고리즘의 조합입니다. 실제 돈으로 3개월 이상 테스트하지 않고 EA를 구입하지 마십시오. 실제 돈으로 BONNITTA EA를 테스트하고 아래 링크에서 결과를 확인하는 데 100주 이상(2년 이상)이 걸렸습니다. BONNITTA EA는 사랑과 권한 부여로 만들어졌습니다. 불법 복제 알고리즘의 가격 및 구현의 이유는 소수의 구매자에게만 해당됩니다. Bonnitta EA는 테스트를 거쳤으며 22년 동안 99,9% 품질의 실제 진드기를 사용하여 실제 시장 조건에 가까운 슬리피지 및 수수료로 스트레스 테스트를 성공적으로 통과했습니다. Expert Advisor에는 완전한 통계 제어를 통해 통계 수집 및 미끄러짐 제어 알고리즘이 포함되어 있습니다
      Bandwagon
      ADELYN CASTILLO
      4.93 (29)
      22번째 달에 240% 수익을 냈습니다. 2년 실적 Bandwagon 2년 또 는 Bandwagon V2 로 Bandwagon Live Account를 확인할 수 있습니다. *메모: 지금 50% 할인 중이에요! 지금 사본을 받으세요! 매달 가격 인상이 예상됩니다. *경고: 불법 복제를 금지하십시오. 악 대차 EA 사본을 요청하는 사용자를 조심하십시오. Bandwagon은 불법 복제를 감지할 수 있으며 귀하의 계정이 그러한 행위를 하는 것으로 감지되면 EA가 계속해서 정상적으로 작동할 것이라고 약속할 수 없습니다. 악대차 특징: Bandwagon은 스윙, 그리드 및 헤징 EA입니다. 자금 관리는 모든 거래 전략에서 매우 중요합니다. Bandwagon은 적절한 자금 관리를 갖추고 있습니다. Bandwagon은 100% 자동화된 EA입니다. EA는 시장이 후퇴했는지, 아니면 언제 추세가 반전되었는지 알고 있습니다. 모든 메이저 및 마이너 쌍에 대해 작업하는 Multicurrency
      Check Screenshot for Each parameters description and customize to your strategy. Note: do not buy any pirated clone in our name we do not sell in any other store other than the official mql5 market, not even on Ebay beware of scammers and do not fall victim out of curiosity. thanks. For Backtesting Parameters For FTMO, if encounter error 130 kindly change spread to 100 from current $ 100 K Below: Pair USTECHCASH100 Cm = "DMF_AI_EA_ROBOT" ; Strategy = 1 ElapsedSECONDS = 7 MaxDailyProfit = 3500 Ma
      Top Algo v4
      Yvan Musatov
      5 (1)
      Торговый робот Top Algo является технической разработкой для автоматизации торговли на валютном Форекс рынке. Его цель — помочь как начинающим участникам рынка, у которых недостаточно фундаментальной базы в сфере трейдинга  так и профессиональным и облегчить опытным инвесторам процесс приумножения прибыли. Top Algo можно также назвать мультивалютным роботом-советником, так как он может работать на нескольких валютных парах.  Профессиональный эксперт Top Algo может подключиться к вашему торгов
      Golden Pickaxe
      Valeriia Mishchenko
      4.67 (6)
      EA has high-performance live track records of different set files: XAU Risky Vol XAU Balanced Vol XAU Balanced MT5 version can be found here Golden Pickaxe is a mean-reversion grid trading system that uses machine learning technology to place high-profit potential trades on the Gold market. It uses real market inefficiencies to its advantage to have an edge over the market. The EA has 5 predefined set files, which are essentially 5 different trading systems on gold . You may choose the def
      ChimeraFxTool
      Marve Edom Agbor
      5 (1)
      CHECK COMMENTS SECTION FOR BACKTESTING PARAMETERS.. The ChimeraFxTool Best EA for Prop Firms (MFF/FTMO The ChimeraFxTool Best EA for Prop Firms (MFF/FTMO)   - No Martingale   - No Grid   - No Hedging Best Risk Management   - Daily Loss limit   - Stop loss and TP protections Best Profit Factor   - Daily Max Profit Lock Protection   - Monthly Profit Lock Protection Best Signal Accuracy    - Best candle Patterns    - Best timed Response     Strategy    - Trend Tracker
      GerFX Density Scalper
      Exler Consulting GmbH
      4.43 (7)
      IMPORTANT: Please contact me after buying or renting for the correct key paramter.  Before you buy a night scalper please be aware of the risks involved: Past performance is no guarantee of future profitability (the EA could also make losses).  The backtests shown (e.g. in screenshots) are highly optimized to find the best parameters but therefore results cannot be transferred to live trading. Any mean reversion can get caught on the wrong side of a fast movements due to unexpected news or flas
      MyGrid Scalper Ultimate
      Ahmad Aan Isnain Shofwan
      2 (1)
      168ドルの価格は、グランドオープンだけの特別価格です。通常価格は$1,688になります MyGrid Scalper Ultimate 8soCfP12Ph19mi914zQaZz2KsGGtcANVhVVfKAnmVRqM ロボットです。 MyGrid Scalper Ultimate は、MyGrid Scalper EA の有料バージョンです https://www.mql5.com/en/market/product/87277 数千人のユーザーが使用していることが証明されています。 MyGrid Scalper Ultimate は派生物であり、Super Grid Scalper EA の一部です。 https://www.mql5.com/en/market/product/85399 MyGrid Scalper Ultimate は、数千人のユーザーが無料版を使用して、実際のアカウントで既に動作する高度なグリッド システムです。したがって、購入する前に無料版を試すことをお勧めします。 特徴: さまざまなロット モード: 固定ロット、
      Diamond Scalping MT4
      Lo Thi Mai Loan
      4.25 (4)
      다음 가격 인상까지 남은 시간은 24시간뿐입니다!  다음 가격: $ 2033 실시간 성과 1 (EURUSD): MT5 버전은 여기에서 확인하실 수 있습니다: 이 EA를 구매하면 Prop 기업의 1일 무료 HFT 패스를 받을 수 있습니다. 자세한 내용은 아래 채팅 채널로 메시지를 보내주십시오. 알림 및 최신 업데이트를 받으려면 채널에 가입하세요: https://www.mql5.com/ko/channels/diamondscalping 거래 시장에서 성공을 거두기 위해 두 가지 접근 방법이 있습니다: 고승률과 작은 리스크 리워드 비율 (RR)로 많은 이익을 얻을 수 있습니다. 낮은 승률일지라도 높은 리스크 리워드 비율 (RR)로 적은 이익을 얻을 수 있습니다. 다양한 전략에 따라 다른 비율이 나오지만, 접근 방법 2의 경우 대부분의 거래자는 성공률이 낮기 때문에 좌절감을 느낄 것입니다. 소수의 거래자만이 이러한 감정적인 도전을 극복하고 손실을 피하고 거래를 포기하지 않
      Scalper Pro Vision
      Kirill Borovskii
      2 (1)
      We present to your attention an advanced tool for scalping trading. This expert has a market-adaptive algorithm and a fully automatic self-learning mode. Therefore, it has a minimum of settings and is intuitive to operate. The advisor is designed specifically for brokers with low spreads and StopLevel less than 5 . The advisor works on pending orders and opens them only in a specified period of time. Characteristics: Working symbols All low spread symbols Working Timeframe: H1 Min deposit: $100
      GoldScalper
      Chiedozie Titus Ugwu
      GoldScalper   is a professional automatic trading system designed and optimized for the MT4 platform and the  XAU/USD   pair. This system works independently on your terminal, you can run it on your computer or on a VPS because the computer must be turned on while the robot is running. The robot analyzes the market 24 hours a day ,Opening its trades on the 5M Timeframe . thanks to which it is more effective than a human. Updates and optimizations are made on an ongoing basis and will be availabl
      Algo v3 ea robot
      Sharif Khatib Said
      1 (1)
      ALGO V3 EA is developed with over a year of intense research and testing. This expert advisor employs multi-timeframe volatility measurements, analyses intentions of market participants and anticipate price movements before they occur with help candlestick patterns, and supply & demand analysis for accurate entries that are highly reactive to market price movements of Gold, breaking out at critical price levels. Gold Mana is proven to be resilient for more than 3 years with stable trading throug
      Algo Samurai Gold
      Abdul Malikul Hanan
      Algo Samurai Gold: Scalp XAUUSD with Built-in Profit Protection Real Account Signal Page :    https://www.mql5.com/en/signals/2235827 https://www.mql5.com/en/signals/2239627 https://www.mql5.com/en/signals/2240852 set file used :   AlgoSamuraiGold Trade Gold with Confidence and Control Algo Samurai Gold is an automated forex trading robot (Expert Advisor) designed to scalp profits from the XAUUSD (Gold) market. This scalping strategy allows you to capitalize on small price movements througho
      App system
      Pierre Paul Amoussou
      구매 후에는 개인 메시지로 보내주세요! 간단한 이동 평균선 및 지수 이동 평균선 신호 및 모멘텀 신호를 기반으로 한 자동화된 거래 로봇으로, Nasdaq 100, EURUSD 및 XAUUSD와 함께 작동하도록 설계되었습니다. 그러나 금시장이 우선입니다. 이 로봇은 이러한 신호를 기반으로 매수 및 매도 주문을 배치하고, 거래되는 시장에 적합한 최소 롯 사이즈를 사용합니다. 테이크 프로핏은 트레이더가 직접 설정하여 더 큰 유연성을 제공합니다. 이 로봇은 15분간격에서 미국 세션 동안 데이 트레이딩을 위해 구성되어 있어 시장 움직임에 더 빠르게 대응할 수 있습니다. 스윙 트레이딩에도 사용할 수 있습니다. 거래일은 트레이더의 선호에 따라 구성할 수 있습니다. 스톱 로스는 자동으로 설정되지만 설정에서 조정할 수도 있습니다. 로봇은 적절한 리스크 관리와 함께 사용되어야 합니다. 데모 버전도 제공됩니다. 구매한 사람에게 설치 및 사용 방법을 설명해드릴 수 있습니다. 백테스팅 결과는 비디오 및
      This Expert Advisor uses 7 indicators and many different mechanisms that control the trading process. To receive a signal, the robot analyzes the indicators of Parabolic SAR, MACD, MA, Envelopes, CCI, RSI, Alligator. Each order is supported by a double grid (with and against a trend order). The recommended deposit is from $ 4000 - on a dollar account, or 4000 cents on a cent account. You need to trade on timeframes from H1, where the trend / flat and pullbacks are better traced. Write to me afte
      Smart Advisor Calculation is designed for a very interesting method that is able finally to give the martingale a new positive way! At startup the Expert Advisor sets virtual orders and trades like the real deal. As soon as the drawdown of virtual orders reaches the set number, the robot immediately enters the market for real orders! Thus the price is going without setbacks such as 30-70 pips, with great probability will kick back at the entrance to the market! This is used by a robot! If the pr
      Forebot
      Marek Kvarda
      This robot uses a custom hidden oscillating indicator and also analyzes the market response. It traded mostly at the time of higher volatility. It works with several pending orders with different size of volume and their position actively modifies. It uses advanced money management. TradingMode setting can also meet the conditions FIFO. It is successful in different markets and different timeframes. Best results are achieves with a broker with the spread to 5 points on EURUSD. Is necessary a b
      Avato
      Nikolaos Bekos
      The Avato is one of our standalone tools. (A Signal based on it will also be provided on Mt4 Market in the future). It is designed around a combined form of hedging and martingale techniques and uses sophisticated algorithms and filters to place the trades. It uses Stop loss and Take profit levels while Lot size is calculated automatically following the according multiplier settings. We consider it a toolbox for every seasoned trader. Made with Gold market in mind, it can be tested in other inst
      AreaFiftyOne
      Valeri Balachnin
      Area 51 EA generates signals on different strategies. Has different money management strategies and dynamic lot size function. When a position is opened, it is equipped with a take profit and a stop loss. If the position becomes profitable, a dynamic stop loss based on the specified values (TrailingStep and DistanceStep) will be set for it and constantly trailed. This allows you to always close positions in profit.  If you want, that your manual opened positions will be handled by the EA, so you
      Note : the spread value,  the broker's slippage and the VPS speed affect the Expert Advisor trading results. Recommendations: gold with spread up to 3, USDJPY with spread up to 1.7, EURUSD with spread up to 1.5. Results will be better with better conditions. The Ping value between VPS and the broker server should be below 10 ms. In addition, the smaller the broker's stop-level requirement, the better; 0 is the best. The Expert Advisor is based on a breakthrough system and carefully controls all
      Milch Cow Extra
      Mohamed Nasseem
      EA is primarily a Hedging and Multiples Strategy. It support to seize every opportunity in any direction as MILCH COW MIX but with multiple profit results without increasing the risk. Milch Cow Mix EA starts to open Hedge at first level only But EA opens Hedge at every level Not just opens the deals, but chooses the right time to close the open positions to begin trading again. We recommend the use of an expert with a pair of high volatility for the currency, such as GBPAUD, AUDCAD Experts inter
      제작자의 제품 더 보기
      Greetings Traders! I'm Pablo, a seasoned trader with over 12 years of experience in stocks, forex, and indices. I mainly trade on the eToro platform, but I also have coding expertise in creating expert advisors for MT4. Understanding the challenges traders face, I've developed an expert advisor designed to ease market analysis and improve trading success. Trading Signal: High Risk :  Click Here   Low Risk :  Click Here Pricing: The current price of the FSI is $1,500 USD. Soon, the price will i
      필터:
      리뷰 없음
      리뷰 답변
      버전 13.47 2024.08.24
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.45 2024.08.20
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.43 2024.08.19
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.42 2024.08.18
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.41 2024.08.17
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.40 2024.08.16
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.39 2024.08.15
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.38 2024.08.15
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.37 2024.08.14
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.36 2024.08.13
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.35 2024.08.13
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.33 2024.08.13
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.32 2024.08.12
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.31 2024.08.10
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.30 2024.08.09
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.29 2024.08.09
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.28 2024.08.09
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.27 2024.08.06
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.26 2024.08.05
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.25 2024.08.04
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.24 2024.07.31
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.23 2024.07.25
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.22 2024.06.27
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.20 2024.06.24
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.15 2024.06.22
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.13 2024.06.22
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.10 2024.06.14
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.9 2024.06.14
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.8 2024.06.14
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.6 2024.06.13
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //-------------
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;
      //-------------
      double shortMA = iMA(global_50_st, 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);
      double longMA = iMA(global_50_st, 0, 200, 0, MODE_SMA, PRICE_CLOSE, 0);
      double rsi = iRSI(global_50_st, 60, 20, PRICE_CLOSE, 0);
      //-------------
      bool isBullish = (shortMA > longMA) && (rsi > 50);
      bool isBearish = (shortMA < longMA) && (rsi < 50);
      bool isOverbought = (rsi > 70);
      bool isOversold = (rsi < 30);
      //-------------
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = true;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = false;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0) ||
      (isBearish && global_56_do > 0) || (isBullish && global_56_do < 0) ||
      (isBearish && global_58_do > 0) || (isBullish && global_58_do < 0) ||
      (isBearish && global_21_do > 0 && isOverbought) || (isBullish && global_21_do < 0 && isOversold) ||
      (isBearish && global_56_do > 0 && isOverbought) || (isBullish && global_56_do < 0 && isOversold) ||
      (isBearish && global_58_do > 0 && isOverbought) || (isBullish && global_58_do < 0 && isOversold)) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;
      }
      }
      }
      버전 13.5 2024.06.12
      void fun_29(int para_0_in) {
      int local_1_in;
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxDrawdownLimit = accountEquity * maxDrawdownLimitPercent;
      double currentDrawdown = accountBalance - accountEquity;

      double shortMA;
      double longMA;
      double rsi;
      int shortMAPeriod = 50;
      int longMAPeriod = 200;
      int rsiPeriod = 14;
      bool isBullish;
      bool isBearish;
      bool isOverbought;
      bool isOversold;

      shortMA = iMA(global_50_st, 0, shortMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);
      longMA = iMA(global_50_st, 0, longMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);
      rsi = iRSI(global_50_st, 0, rsiPeriod, PRICE_CLOSE, 0);

      isBullish = (shortMA > longMA) && (rsi > 50);
      isBearish = (shortMA < longMA) && (rsi < 50);
      isOverbought = (rsi > 70);
      isOversold = (rsi < 30);

      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + drawdownDurationHours * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + maxDrawdownCheckDays * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in, 2, 48);
      if (StringLen(global_50_st) != 6) {
      tmp_st_1 = "99";
      } else {
      tmp_st_1 = fun_20(StringSubstr(global_50_st, 0, 3)) + fun_20(StringSubstr(global_50_st, 3, 3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st);
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in));
      global_42_do = LotsMartinp;
      global_18_in = global_19_in;
      if ((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != "")) {
      local_1_in = para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2;
      global_21_do = global_2_a_160_ko[local_1_in].do_3;
      global_28_do = global_2_a_160_ko[local_1_in].do_4;
      global_29_do = global_2_a_160_ko[local_1_in].do_5;
      global_30_in = global_2_a_160_ko[local_1_in].do_6;
      global_31_do = global_2_a_160_ko[local_1_in].do_7;
      global_33_do = global_2_a_160_ko[local_1_in].do_8;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in));
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in));
      global_129_do = MarketInfo(global_50_st, 13);
      global_125_do = MarketInfo(global_50_st, 13) * MarketInfo(global_50_st, 11);
      global_126_do = MarketInfo(global_50_st, 10);
      global_127_do = MarketInfo(global_50_st, 9);
      global_128_do = MarketInfo(global_50_st, 11);
      global_130_do = 0.0;
      if (iClose(global_50_st, 0, 1) > 0.0) {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st, 0, 1) - 1.0)) * 10000.0;
      }
      fun_13();
      if (iATR(global_50_st, 1440, global_22_in, 1) / MarketInfo(global_50_st, 9) > global_23_do) {
      global_123_bo = false;
      return;
      }
      global_123_bo = true;

      if ((isBearish && global_21_do > 0) || (isBullish && global_21_do < 0)) {
      global_123_bo = false;
      return;
      }
      }
      }
      버전 13.2 2024.06.11
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 12.5 2024.06.11
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 12.3 2024.06.07
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 11.5 2024.06.07
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 11.0 2024.06.07
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 9.9 2024.06.07
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 9.0 2024.06.07
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      Version 7.5 2024.06.03
      버전 7.9 2024.06.06
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 7.5 2024.06.03
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 7.1 2024.06.02
      void fun_29(int para_0_in)
      {
      int local_1_in;
      //----- -----
      string tmp_st_1;
      string tmp_st_2;
      string tmp_st_3;
      static datetime maxDrawdownStartTime = 0;
      static datetime maxDrawdownEndTime = 0;
      static bool drawdownPaused = False;
      static datetime maxDrawdownCheckTime = 0;
      static double movingAverageDrawdown = 0.0;
      static int drawdownPeriod = 14;
      static double emergencyStopLimit = 0.2;
      double accountBalance = AccountBalance();
      double accountEquity = AccountEquity();
      double maxFixedDrawdownLimit = accountEquity * 0.09;
      double maxDynamicDrawdownLimit = movingAverageDrawdown * 1.2;
      double maxDrawdownLimit = MathMin(maxFixedDrawdownLimit, maxDynamicDrawdownLimit);
      double currentDrawdown = accountBalance - accountEquity;
      //----- -----
      if (maxDrawdownCheckTime == 0) {
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      static double drawdownHistory[14] = {0};
      static int drawdownIndex = 0;
      drawdownHistory[drawdownIndex] = currentDrawdown;
      drawdownIndex = (drawdownIndex + 1) % drawdownPeriod;
      double drawdownSum = 0.0;
      for (int i = 0; i < drawdownPeriod; i++) {
      drawdownSum += drawdownHistory[i];
      }
      movingAverageDrawdown = drawdownSum / drawdownPeriod;
      if (currentDrawdown / accountEquity >= emergencyStopLimit) {
      drawdownPaused = True;
      Print("Emergency stop triggered! Drawdown exceeded ", emergencyStopLimit * 100, "%.");
      return;
      }
      if (currentDrawdown >= maxDrawdownLimit && !drawdownPaused && TimeCurrent() >= maxDrawdownCheckTime) {
      maxDrawdownStartTime = TimeCurrent();
      maxDrawdownEndTime = TimeCurrent() + 24 * 60 * 60;
      drawdownPaused = True;
      maxDrawdownCheckTime = TimeCurrent() + 7 * 24 * 60 * 60;
      }
      if (TimeCurrent() >= maxDrawdownEndTime && drawdownPaused) {
      drawdownPaused = False;
      maxDrawdownStartTime = 0;
      maxDrawdownEndTime = 0;
      }
      if (!drawdownPaused) {
      global_93_st = IntegerToString(para_0_in,2,48) ;
      if(StringLen(global_50_st) != 6)
      {
      tmp_st_1 = "99";
      }
      else
      {
      tmp_st_1 = fun_20(StringSubstr(global_50_st,0,3)) + fun_20(StringSubstr(global_50_st,3,3));
      }
      global_26_in = StringToInteger(tmp_st_1 + global_93_st) ;
      global_25_in = GlobalVariableGet(string(IsTesting()) + "Magic" + global_50_st + string(global_26_in)) ;
      global_42_do = LotsMartinp ;
      global_18_in = global_19_in ;
      if((global_3_in != 1 || StringTrimLeft(StringTrimRight(global_4_st)) != ""))
      {
      local_1_in=para_0_in - 1;
      global_18_in = global_2_a_160_ko[local_1_in].in_2 ;
      global_21_do = global_2_a_160_ko[local_1_in].do_3 ;
      global_28_do = global_2_a_160_ko[local_1_in].do_4 ;
      global_29_do = global_2_a_160_ko[local_1_in].do_5 ;
      global_30_in = global_2_a_160_ko[local_1_in].do_6 ;
      global_31_do = global_2_a_160_ko[local_1_in].do_7 ;
      global_33_do = global_2_a_160_ko[local_1_in].do_8 ;
      }
      global_14_in = GlobalVariableGet(string(IsTesting()) + "NUMBER" + global_50_st + string(global_26_in)) ;
      global_69_do = GlobalVariableGet(string(IsTesting()) + "Distance_Price" + global_50_st + string(global_26_in)) ;
      global_129_do = MarketInfo(global_50_st,13) ;
      global_125_do = MarketInfo(global_50_st,13) * MarketInfo(global_50_st,11) ;
      global_126_do = MarketInfo(global_50_st,10) ;
      global_127_do = MarketInfo(global_50_st,9) ;
      global_128_do = MarketInfo(global_50_st,11) ;
      global_130_do = 0.0 ;
      if(iClose(global_50_st,0,1)>0.0)
      {
      global_130_do = (MathAbs(global_127_do / iClose(global_50_st,0,1) - 1.0)) * 10000.0 ;
      }
      fun_13();
      if(iATR(global_50_st,86400,global_22_in,1) / MarketInfo(global_50_st,9)>global_23_do)
      {
      global_123_bo = false ;
      return;
      }
      global_123_bo = true ;
      }
      }
      버전 7.0 2024.06.01
      In the new update of the Orion Intelligence System,

      I implemented new privacy measures against scammers and those who attempt to crack my EA.

      If they try to crack it and use it on their live account,

      it will generate errors. We worked on this EA for over three years, dedicating a lot of time to its development,

      so that traders who are struggling with their trades can benefit from it.
      버전 5.9 2024.05.31
      MultiCurrency Mode separated by comma (Limit to 9)
      버전 5.5 2024.05.28
      MultiCurrency Mode separated by comma (Limit to 9)
      버전 5.0 2024.05.28
      MultiCurrency Mode separated by comma (Limit to 9)
      버전 3.9 2024.05.27

      In the new update of the Orion Intelligence System,
      I implemented new privacy measures against scammers and those who attempt to crack my EA.
      If they try to crack it and use it on their live account,
      it will generate errors. We worked on this EA for over three years, dedicating a lot of time to its development,
      so that traders who are struggling with their trades can benefit from it.






      버전 3.5 2024.05.26
      The latest update (v3.5) of our EA brings critical changes to the setting of stoploss for both OP_SELL and OP_BUY orders. In this update, we have optimized the setting of stoploss by adjusting their values to provide better protection against unexpected market movements. This update enhances safety and security for our clients while they engage in forex trading.
      버전 3.0 2024.05.25
      The latest update (v3.0) of our EA brings critical changes to the setting of stoploss for both OP_SELL and OP_BUY orders. In this update, we have optimized the setting of stoploss by adjusting their values to provide better protection against unexpected market movements. This update enhances safety and security for our clients while they engage in forex trading.
      버전 1.7 2024.05.17
      The latest update (v1.7) of our EA brings critical changes to the setting of stoploss for both OP_SELL and OP_BUY orders. In this update, we have optimized the setting of stoploss by adjusting their values to provide better protection against unexpected market movements. This update enhances safety and security for our clients while they engage in forex trading.
      버전 1.5 2024.05.17
      The latest update (v1.5) of our EA brings critical changes to the setting of stoploss for both OP_SELL and OP_BUY orders. In this update, we have optimized the setting of stoploss by adjusting their values to provide better protection against unexpected market movements. This update enhances safety and security for our clients while they engage in forex trading.