code: def _generate_range_overflow_safe(
      endpoint, periods, stride, side="start"
  ):
      """
      Calculate the second endpoint for passing to np.arange, checking
      to avoid an integer overflow.  Catch OverflowError and re-raise
      as OutOfBoundsDatetime.
  
      Parameters
      ----------
      endpoint : int
          nanosecond timestamp of the known endpoint of the desired range
      periods : int
          number of periods in the desired range
      stride : int
          nanoseconds between periods in the desired range
      side : {'start', 'end'}
          which end of the range `endpoint` refers to
  
      Returns
      -------
      other_end : int
  
      Raises
      ------
      OutOfBoundsDatetime
      """
      # GH#14187 raise instead of incorrectly wrapping around
      assert side in ["start", "end"]
  
      i64max = np.uint64(np.iinfo(np.int64).max)
      msg = (
          "Cannot generate range with {side}={endpoint} and "
          "periods={periods}".format(
              side=side, endpoint=endpoint, periods=periods
          )
      )
  
      with np.errstate(over="raise"):
          # if periods * strides cannot be multiplied within the *uint64* bounds,
          #  we cannot salvage the operation by recursing, so raise
          try:
              addend = np.uint64(periods) * np.uint64(np.abs(stride))
          except FloatingPointError:
              raise OutOfBoundsDatetime(msg)
  
      if np.abs(addend) <= i64max:
          # relatively easy case without casting concerns
          return _generate_range_overflow_safe_signed(
              endpoint, periods, stride, side
          )
  
      elif (endpoint > 0 and side == "start" and stride > 0) or (
          endpoint < 0 and side == "end" and stride > 0
      ):
          # no chance of not-overflowing
          raise OutOfBoundsDatetime(msg)
  
      elif (
          side == "end"
          and endpoint > i64max
          and endpoint - stride <= i64max
      ):
          # in _generate_regular_range we added `stride` thereby overflowing
          #  the bounds.  Adjust to fix this.
          return _generate_range_overflow_safe(
              endpoint - stride, periods - 1, stride, side
          )
  
      # split into smaller pieces
      mid_periods = periods // 2
      remaining = periods - mid_periods
      assert 0 < remaining < periods, (
          remaining,
          periods,
          endpoint,
          stride,
      )
  
      midpoint = _generate_range_overflow_safe(
          endpoint, mid_periods, stride, side
      )
      return _generate_range_overflow_safe(
          midpoint, remaining, stride, side
      )
  
imports: import numpy
  from pandas._libs.tslibs import OutOfBoundsDatetime, Timestamp
  from pandas.tseries.offsets import Tick, generate_range
label_desc: Use image node_id 2 for calling a global function with example usage: _generate_range_overflow_safe(endpoint, periods, stride, side) and returns: _generate_range_overflow_safe, _generate_range_overflow_safe_signed, _generate_range_overflow_safe