code: def next_fast_len(target):
      """
      Find the next fast size of input data to `fft`, for zero-padding, etc.
  
      SciPy's FFTPACK has efficient functions for radix {2, 3, 4, 5}, so this
      returns the next composite of the prime factors 2, 3, and 5 which is
      greater than or equal to `target`. (These are also known as 5-smooth
      numbers, regular numbers, or Hamming numbers.)
  
      Parameters
      ----------
      target : int
          Length to start searching from. Must be a positive integer.
  
      Returns
      -------
      out : int
          The first 5-smooth number greater than or equal to `target`.
  
      Notes
      -----
      .. versionadded:: 0.18.0
  
      Examples
      --------
      On a particular machine, an FFT of prime length takes 133 ms:
  
      >>> from scipy import fftpack
      >>> import numpy as np
      >>> rng = np.random.default_rng()
      >>> min_len = 10007  # prime length is worst case for speed
      >>> a = rng.standard_normal(min_len)
      >>> b = fftpack.fft(a)
  
      Zero-padding to the next 5-smooth length reduces computation time to
      211 us, a speedup of 630 times:
  
      >>> fftpack.next_fast_len(min_len)
      10125
      >>> b = fftpack.fft(a, 10125)
  
      Rounding up to the next power of 2 is not optimal, taking 367 us to
      compute, 1.7 times as long as the 5-smooth size:
  
      >>> b = fftpack.fft(a, 16384)
  
      """
      # Real transforms use regular sizes so this is backwards compatible
      return _helper.good_size(target, True)
  
imports: import operator
  import numpy
  from numpy.fft import fftshift, ifftshift, fftfreq
  import scipy.fft._pocketfft.helper
label_desc: Use image node_id 2 for calling a global function with example usage: next_fast_len(target) and returns: _helper