reverse(array, newFirstIndex, toIndex);
    reverse(array, fromIndex, toIndex);
  }

  /**
   * Returns an array containing each value of {@code collection}, converted to a {@code double}
   * value in the manner of {@link Number#doubleValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *

// license that can be found in the LICENSE file.

// Package tar implements access to tar archives.
//
// Tape archives (tar) are a file format for storing a sequence of files that
// can be read and written in a streaming manner.
// This package aims to cover most variations of the format,
// including those produced by GNU and BSD tar tools.
package tar

import (
	"errors"
	"fmt"
	"internal/godebug"
	"io/fs"
	"maps"
	"math"

      },
      "french_stop": {
        "type":       "stop",
        "stopwords":  "_french_"
      },
      "french_keywords": {
        "type":       "keyword_marker",
        "keywords": ["Bonjour", "monde", "recherche"]
      },
      "french_stemmer": {
        "type":       "stemmer",
        "language":   "light_french"
      },
      "german_stop": {
        "type":       "stop",

		}
		// CopyObject optimization where we don't create an entire copy
		// of the content, instead we add a reference, we disallow legacy
		// objects to be self referenced in this manner so make sure
		// that we actually create a new dataDir for legacy objects.
		if dstOpts.Versioned && srcOpts.VersionID != dstOpts.VersionID && !srcInfo.Legacy {
			srcInfo.versionOnly = true

    reverse(array, newFirstIndex, toIndex);
    reverse(array, fromIndex, toIndex);
  }

  /**
   * Returns an array containing each value of {@code collection}, converted to a {@code long} value
   * in the manner of {@link Number#longValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *

In the absence of data races, Go programs behave as if all the goroutines
were multiplexed onto a single processor.
This property is sometimes referred to as DRF-SC: data-race-free programs
execute in a sequentially consistent manner.
</p>

<p>
While programmers should write Go programs without data races,
there are limitations to what a Go implementation can do in response to a data race.

  final int concurrencyLevel;

  /** Strategy for comparing keys. */
  final Equivalence<Object> keyEquivalence;

  /** Strategy for handling entries and segments in a type-safe and efficient manner. */
  final transient InternalEntryHelper<K, V, E, S> entryHelper;

  /**
   * Creates a new, empty map with the specified strategy, initial capacity and concurrency level.
   */

      }
      return message.toString();
    }
  }

  /**
   * Internal Lock implementations implement the {@code CycleDetectingLock} interface, allowing the
   * detection logic to treat all locks in the same manner.
   */
  private interface CycleDetectingLock {

    /**
     * @return the {@link LockGraphNode} associated with this lock.
     */
    LockGraphNode getLockGraphNode();

    /**

,OAAgB,MAATrD,EAAgBP,KAAO0E,IAElC,IAAI2M,GAAWrR,KAAKqT,MAAQ,EAAIrT,KAAK+I,aAAa6T,MAAM7L,KAAO,EAC/D,OAAgB,MAATxQ,EAAgB8Q,EAAUrR,KAAK+e,IAAIxe,EAAQ8Q,EAAS,MA8oG/DqV,GAAMa,WA3oGN,SAA4BhnB,GACxB,IAAKP,KAAK4D,UACN,OAAgB,MAATrD,EAAgBP,KAAO0E,IAOlC,GAAa,MAATnE,EAIA,OAAOP,KAAKqT,OAAS,EAHrB,IAjOiB9S,EAAO8B,EAiOpBgP,GAjOa9Q,EAiOaA,EAjON8B,EAiOarC,KAAK+I,aAhOzB,iBAAVxI,EACA8B,EAAOmQ,cAAcjS,GAAS,GAAK,EAEvC0D,MAAM1D,GAAS,KAAOA,GA8NzB,OAAOP,KAAKqT,IAAIrT,KAAKqT,MAAQ,EAAIhC,EAAUA,EAAU,IAioG7DqV,GAAMnV,UAhMN,SA...

   * SoftReference} (by default, strong references are used). Softly-referenced objects will be
   * garbage-collected in a <i>globally</i> least-recently-used manner, in response to memory
   * demand.
   *
   * <p><b>Warning:</b> in most circumstances it is better to set a per-cache {@linkplain