checkNotNull(target, "target");
    if (target.length == 0) {
      return 0;
    }

    outer:
    for (int i = 0; i < array.length - target.length + 1; i++) {
      for (int j = 0; j < target.length; j++) {
        if (array[i + j] != target[j]) {
          continue outer;
        }
      }
      return i;
    }
    return -1;
  }

  /**

    checkNotNull(target, "target");
    if (target.length == 0) {
      return 0;
    }

    outer:
    for (int i = 0; i < array.length - target.length + 1; i++) {
      for (int j = 0; j < target.length; j++) {
        if (array[i + j] != target[j]) {
          continue outer;
        }
      }
      return i;
    }
    return -1;
  }

  /**

    checkNotNull(target, "target");
    if (target.length == 0) {
      return 0;
    }

    outer:
    for (int i = 0; i < array.length - target.length + 1; i++) {
      for (int j = 0; j < target.length; j++) {
        if (array[i + j] != target[j]) {
          continue outer;
        }
      }
      return i;
    }
    return -1;
  }

  /**

    }

    private static final Logger logger = LogManager.getLogger(RelatedContentHelper.class);

    /**
     * Cache map storing related content configurations organized by virtual host key.
     * The outer map key is the virtual host key, and the value is a pair containing:
     * - First: Map of exact term matches (term -> content)
     * - Second: List of regex pattern matches (Pattern -> content template)
     */

        assertFalse(it.hasNext(), "Iterator exhausted after valid entries");
        verify(tree, times(1)).release(); // closed after exhaustion
    }

    @ParameterizedTest
    @ValueSource(strings = { "", "file.txt", "subdir" })
    @DisplayName("Name filter interaction: accept calls and rejections")
    void nameFilterAccepts(String acceptedName) throws Exception {
        // Arrange
        stubAcquireReturnsSelf();

        }

        // Calculate inner hash
        md5.reset();
        md5.update(ipad);
        md5.update(data);
        byte[] innerHash = md5.digest();

        // Calculate outer hash
        md5.reset();
        md5.update(opad);
        byte[] expectedResult = md5.digest(innerHash);

        // Test HMACT64 implementation

                        innerCount++;
                    }
                }
                assertEquals(0, innerCount, "Inner iteration should not execute");
            }
            assertEquals(0, outerCount, "Outer iteration should not execute");
        }, "EmptyIterator should work correctly in nested iteration");
    }

    @Test
    @DisplayName("EmptyIterator should follow Iterator contract for empty collections")

    checkNotNull(target, "target");
    if (target.length == 0) {
      return 0;
    }

    outer:
    for (int i = 0; i < array.length - target.length + 1; i++) {
      for (int j = 0; j < target.length; j++) {
        if (array[i + j] != target[j]) {
          continue outer;
        }
      }
      return i;
    }
    return -1;
  }

  /**

    class BaseWithTypeVar<T> {}
    class Outer<O> {
      class Sub<X> extends BaseWithTypeVar<List<X>> {}

      class Sub2<Y extends Sub2<Y>> extends BaseWithTypeVar<List<Y>> {}
    }
    ParameterizedType subtype =
        (ParameterizedType)
            new TypeToken<BaseWithTypeVar<List<?>>>() {}.getSubtype(Outer.Sub.class).getType();
    assertEquals(Outer.Sub.class, subtype.getRawType());

    checkNotNull(target, "target");
    if (target.length == 0) {
      return 0;
    }

    outer:
    for (int i = 0; i < array.length - target.length + 1; i++) {
      for (int j = 0; j < target.length; j++) {
        if (array[i + j] != target[j]) {
          continue outer;
        }
      }
      return i;
    }
    return -1;
  }

  /**