Fix IndexOutOfRangeException in RegexInterpreter.Backtrack method

src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexInterpreter.cs

@@ -129,7 +129,16 @@
         {
             CheckTimeout(); // to ensure that any backtracking operation has a timeout check
 
-            int newpos = runtrack![runtrackpos];
+            // Check if we've exhausted the backtrack stack
+            if (runtrackpos >= runtrack!.Length)
+            {
+                // Match failed, so we should just return with no match
+                runmatch!.FoundMatch = false;
+                SetOperator(RegexOpcode.Stop);
+                return;
+            }
+
+            int newpos = runtrack[runtrackpos];
             runtrackpos++;
 
             int back = (int)RegexOpcode.Backtracking;

src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/RegexBacktrackingTests.cs

@@ -0,0 +1,44 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace System.Text.RegularExpressions.Tests
+{
+    public class RegexBacktrackingTests
+    {
+        [Fact]
+        public void PossessiveQuantifierWithLazyQuantifierShouldNotThrow()
+        {
+            // This specific pattern caused IndexOutOfRangeException before the fix
+            var regex = new Regex(@"(?>(-*)+?-*)$");
+
+            // Test with input that would previously throw
+            Match match = regex.Match("test");
+
+            // Verify it doesn't throw and correctly reports no match
+            Assert.False(match.Success, "When backtracking stack is exhausted, match should be unsuccessful");
+        }
+
+        [Theory]
+        [InlineData(@"(?>(-*)+?-*)$", "test", false)]
+        [InlineData(@"(?>(-*)+?-*)$", "abcdef", false)]
+        [InlineData(@"(?>(-+)+?-*)$", "test", false)]
+        [InlineData(@"(?>a*)+?", "aaaaaaaa", true)]
+        [InlineData(@"(?>(-{50000})+?-*)$", "test", false)]  // Large repeat count
+        [InlineData(@"((?>a+)+b)+c", "aababc", true)]      // Complex nesting
+        public void ComplexBacktrackingShouldNotThrow(string pattern, string input, bool expectedMatch)
+        {
+            // Tests various patterns that might stress the backtracking system
+            var regex = new Regex(pattern);
+
+            // Act - should not throw
+            Match match = regex.Match(input);
+
+            // Verify expected match result
+            Assert.Equal(expectedMatch, match.Success);
+        }
+    }
+}

src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/System.Text.RegularExpressions.Tests.csproj

@@ -34,6 +34,7 @@
     <Compile Include="Regex.Split.Tests.cs" />
     <Compile Include="Regex.Tests.Common.cs" />
     <Compile Include="Regex.UnicodeChar.Tests.cs" />
+    <Compile Include="RegexBacktrackingTests.cs" />
     <Compile Include="RegexCharacterSetTests.cs" />
     <Compile Include="RegexCultureTests.cs" />
     <Compile Include="RegexMatchTimeoutExceptionTests.cs" />