code: public static IntStreamEx rangeClosed(int startInclusive, int endInclusive, int step) {
          if (step == 0)
              throw new IllegalArgumentException("step = 0");
          if (step == 1)
              return seq(IntStream.rangeClosed(startInclusive, endInclusive));
          if (step == -1) {
              // Handled specially as number of elements can exceed
              // Integer.MAX_VALUE
              int sum = endInclusive + startInclusive;
              return seq(IntStream.rangeClosed(endInclusive, startInclusive).map(x -> sum - x));
          }
          if (endInclusive > startInclusive ^ step > 0)
              return empty();
          int limit = (endInclusive - startInclusive) * Integer.signum(step);
          limit = Integer.divideUnsigned(limit, Math.abs(step));
          return seq(IntStream.rangeClosed(0, limit).map(x -> x * step + startInclusive));
      }
docs: Returns a sequential ordered {@code IntStreamEx} from
  {@code startInclusive} (inclusive) to {@code endInclusive} (inclusive) by
  the specified incremental step. The negative step values are also
  supported. In this case the {@code startInclusive} should be greater than
  {@code endInclusive}.
  
  <p>
  Note that depending on the step value the {@code endInclusive} bound may
  still not be reached. For example
  {@code IntStreamEx.rangeClosed(0, 5, 2)} will yield the stream of three
  numbers: 0, 2 and 4.
  
  @param startInclusive the (inclusive) initial value
  @param endInclusive the inclusive upper bound
  @param step the non-zero value which designates the difference between
  the consecutive values of the resulting stream.
  @return a sequential {@code IntStreamEx} for the range of {@code int}
  elements
  @throws IllegalArgumentException if step is zero
  @see IntStreamEx#rangeClosed(int, int)
  @since 0.4.0