Why-my-backtest-has-a-NSF-position-count-so-high

QUOTE:
The answer could likely be found somewhere else: preferences, strategy code, market details etc.

CODE:
using System.Collections.Generic;

using WealthLab.Backtest;
using WealthLab.Core;
using WealthLab.Indicators;


namespace Strategies
{
    public class StrategyName : UserStrategyBase
    {
        // Params:
        int rollingWindow;

        // Timeseries:
        IndicatorBase highestHigh;
        IndicatorBase lowestLow;

        public override void BacktestBegin()
        {
            WriteToDebugLog("Backtest started.");
        }

        public StrategyName()
        {
            AddParameter("rollingWindow", ParameterTypes.Int32, 125, 5, 750, 5);
        }

        public override void Initialize(BarHistory bars)
        {
            rollingWindow = Parameters.FindName("rollingWindow").AsInt;

            highestHigh = Highest.Series(bars.High, rollingWindow);
            lowestLow = Lowest.Series(bars.Low, rollingWindow);

            PlotIndicator(highestHigh);
            PlotIndicator(lowestLow);

            StartIndex = rollingWindow;
        }

        public override void Execute(BarHistory bars, int idx)
        {
            List<Position> longOpenPositions = new List<Position>();
            List<Position> shortOpenPositions = new List<Position>();

            bool commonOpeningFilters;
            bool commonClosingFilters;

            // PREPROCESSING.
            {
                List<Position> openPositions = OpenPositions;

                foreach (Position pos in openPositions)
                {
                    if (pos.PositionType == PositionType.Long)
                        longOpenPositions.Add(pos);
                    if (pos.PositionType == PositionType.Short)
                        shortOpenPositions.Add(pos);
                }
            }

            // COMMON OPENING FILTERS.
            {
                commonOpeningFilters = true;
            }

            if (commonOpeningFilters)
            {
                // LONG OPENING.
                {
                    bool longOpeningFilters = true;
                    bool longOpeningSignal = true;

                    if (longOpeningFilters && longOpeningSignal)
                    {
                        PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
                    }
                }

                // SHORT OPENING.
                {
                    bool shortOpeningFilters = true;
                    bool shortOpeningSignal = true;

                    if (shortOpeningFilters && shortOpeningSignal)
                    {
                        PlaceTrade(bars, TransactionType.Short, OrderType.Market);
                    }
                }
            }

            if (longOpenPositions.Count > 0 || shortOpenPositions.Count > 0)
            {
                // COMMON CLOSING FILTERS.
                {
                    commonClosingFilters = true;
                }

                // LONG CLOSING.
                if (commonClosingFilters && longOpenPositions.Count > 0)
                {
                    foreach (Position pos in longOpenPositions)
                    {
                        if (pos == null)
                            continue;

                        bool longClosingFilters = true;
                        bool longClosingSignal = true;

                        if (longClosingFilters && longClosingSignal)
                        {
                            ClosePosition(pos, OrderType.Market);
                        }
                    }
                }

                // SHORT CLOSING.
                if (commonClosingFilters && shortOpenPositions.Count > 0)
                {
                    foreach (Position pos in shortOpenPositions)
                    {
                        if (pos == null)
                            continue;

                        bool shortClosingFilters = true;
                        bool shortClosingSignal = true;

                        if (shortClosingFilters && shortClosingSignal)
                        {
                            ClosePosition(pos, OrderType.Market);
                        }
                    }
                }
            }
        }

        public override void BacktestComplete()
        {
            WriteToDebugLog("Backtest done.");
        }
    }
}