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

    private static final String[] CAT_NAMES =
            { "aliases", "allocation", "count", "fielddata", "health", "indices", "master", "nodeattrs", "nodes", "pending_tasks",
                    "plugins", "recovery", "repositories", "thread_pool", "shards", "segments", "snapshots", "templates" };

   * collection-based APIs. Further, this method allows precise control over the runtime type of the
   * output array, and may, under certain circumstances, be used to save allocation costs.
   *
   * <p>Suppose {@code x} is a queue known to contain only strings. The following code can be used
   * to dump the queue into a newly allocated array of {@code String}:
   *
   * <pre>

   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Floats.asList(array),
   * distance)}, but is considerably faster and avoids allocation and garbage collection.
   *
   * <p>The provided "distance" may be negative, which will rotate left.
   *
   * @since 32.0.0
   */
  public static void rotate(float[] array, int distance) {

   * collection-based APIs. Further, this method allows precise control over the runtime type of the
   * output array, and may, under certain circumstances, be used to save allocation costs.
   *
   * <p>Suppose {@code x} is a queue known to contain only strings. The following code can be used
   * to dump the queue into a newly allocated array of {@code String}:
   *
   * <pre>

   * + i) mod array.length}. This is equivalent to {@code Collections.rotate(Bytes.asList(array),
   * distance)}, but is considerably faster and avoids allocation and garbage collection.
   *
   * <p>The provided "distance" may be negative, which will rotate left.
   *
   * @since 32.0.0
   */
  public static void rotate(double[] array, int distance) {

   * #aboutToAcquire(CycleDetectingLock)} and {@link #lockStateChanged(CycleDetectingLock)}.
   */
  // This is logically a Set, but an ArrayList is used to minimize the amount
  // of allocation done on lock()/unlock().
  private static final ThreadLocal<List<LockGraphNode>> acquiredLocks =
      new ThreadLocal<List<LockGraphNode>>() {
        @Override
        protected List<LockGraphNode> initialValue() {

        }
      }
      return new EntrySetImpl();
    }

    @Override
    public void forEach(BiConsumer<? super K, ? super V> action) {
      checkNotNull(action);
      // avoids allocation of entries
      backingSet().forEach(k -> action.accept(k, function.apply(k)));
    }
  }

  static <K extends @Nullable Object, V extends @Nullable Object>

        previous gradient implementation.
    *   Added a new session config setting `internal_fragmentation_fraction`,
        which controls when the BFC Allocator needs to split an oversized chunk
        to satisfy an allocation request.
    *   Added `tf.get_current_name_scope()` which returns the current full name
        scope string that will be prepended to op names.
*   `tf.data`:

compared lexically byte-wise:
</p>

<pre>
min(x, y)    == if x &lt;= y then x else y
min(x, y, z) == min(min(x, y), z)
</pre>

<h3 id="Allocation">Allocation</h3>

<p>
The built-in function <code>new</code> creates a new, initialized
<a href="#Variables">variable</a> and returns
a <a href="#Pointer_types">pointer</a> to it.

    cmd = """sed -E "s/>=/==/" $(location nvidia-requirements.txt) > $@;""",
)

compile_pip_requirements(
    name = "requirements",
    srcs = [
        "nvidia-requirements.txt",
        "requirements.in",
        ":nvidia_constraints",
    ],
    extra_args = [
        "--allow-unsafe",
        "--build-isolation",
        "--rebuild",
        "-c $(location :nvidia_constraints)",
    ],