* {@link ImmutableList}) instead of the general collection interface type (such as {@link List}).
 * This communicates to your callers all of the semantic guarantees listed above, which is almost
 * always very useful information.
 *
 * <p>On the other hand, a <i>parameter</i> type of {@link ImmutableList} is generally a nuisance to
 * callers. Instead, accept {@link Iterable} and have your method or constructor body pass it to the

  }

  /*
   * We don't assert that the lock is held during calls to iterator(), stream(), and spliterator:
   * `Synchronized` doesn't guarantee that it will hold the mutex for those calls because callers
   * are responsible for taking the mutex themselves:
   * https://docs.oracle.com/en/java/javase/22/docs/api/java.base/java/util/Collections.html#synchronizedCollection(java.util.Collection)
   *

        Assertions.assertThrows(NullPointerException.class, () -> {
            // Intentionally dereference null to validate exception behavior
            // This checks that callers must handle null references defensively
            info.getSize();
        });
    }

 * supertype of `Function<A, B>` turns out to be massively more useful to callers in practice: They
 * want their output to be non-null in operations like `stream.map(myConverter)`, and we can
 * guarantee that as long as we also require the input type to be non-null[*] (which is a
 * requirement that existing callers already fulfill).
 *
 * Disclaimer: Part of the reason that callers are so well adapted to `Function<A, B>` may be that

    return seq.length() - pos;
  }

  /*
   * To avoid the need to call requireNonNull so much, we could consider more clever approaches,
   * such as:
   *
   * - Make checkOpen return the non-null `seq`. Then callers can assign that to a local variable or
   *   even back to `this.seq`. However, that may suggest that we're defending against concurrent
   *   mutation, which is not an actual risk because we use `synchronized`.

   * code would be responsible for populating a "real" {@code T} (which might still be the value
   * {@code null}!) before returning it to callers. Depending on how the code is structured, a
   * nullness analysis might not understand that the field has been populated. To avoid that problem
   * without having to add {@code @SuppressWarnings}, the code can call this method.

        System.err.println("Target branch: " + targetBranch + " (" + targetSha + ")");
        System.err.println("PR head: " + prHead);
        System.err.println("Base: " + baseSha);

        // One SHA per line to stdout so callers can pipe safely.
        System.out.print(stdout("git", "rev-list", baseSha + ".." + prHead));
    }

    private static boolean refExists(String ref) throws IOException, InterruptedException {

	MD5Hex     string
	SHA256Hex  string
	Size       int64
	ActualSize int64
	DisableMD5 bool
	ForceMD5   []byte
}

// NewReaderWithOpts is like NewReader but takes `Options` as argument, allowing
// callers to indicate if they want to disable md5sum checksum.
func NewReaderWithOpts(ctx context.Context, src io.Reader, opts Options) (*Reader, error) {
	// return hard limited reader

         * requireNonNull is safe because the callers promise to put non-null objects in the first
         * `length` array elements.
         */
        @SuppressWarnings("unchecked") // our callers put only E instances into the array
        E onlyElement = (E) requireNonNull(elements[0]);
        return of(onlyElement);
      default:
        /*
         * The suppression is safe because the callers promise to put non-null objects in the first

		b = ""
	}
	if len(b) > 0 && !strings.HasSuffix(b, slashSeparator) {
		b += slashSeparator
	}
	return b
}

// update cache with new status.
// The updates are conditional so multiple callers can update with different states.
func (m *metacache) update(update metacache) {
	now := UTCNow()
	m.lastUpdate = now

	if update.lastHandout.After(m.lastHandout) {
		m.lastHandout = update.lastUpdate