return !set.isEmpty() ? set.last() : null;
  }

  public ImmutableSortedSet<E> headSet(E toElement, boolean inclusive) {
    checkNotNull(toElement);
    if (inclusive) {
      E tmp = higher(toElement);
      if (tmp == null) {
        return this;
      }
      toElement = tmp;
    }
    return headSet(toElement);
  }

  public E last() {
    return sortedDelegate.last();
  }

    }
  }

  public static class DegeneratedImmutableSetGenerator extends TestStringSetGenerator {
    // Make sure we get what we think we're getting, or else this test
    // is pointless
    @SuppressWarnings("cast")
    @Override
    protected Set<String> create(String[] elements) {
      return (ImmutableSet<String>) ImmutableSet.of(elements[0], elements[0]);
    }
  }

	if s.pos >= atomic.LoadInt64(&s.end) {
		return nullByte
	}
	s.ipos++

	if s.ipos > s.ifill { // internal buffer is exhausted
		s.ifill = <-s.fillReady

		s.buf[0] = s.buf[len(s.buf)-1] // copy current last item to guarantee lookback
		copy(s.buf[1:], s.nbuf[:])     // copy contents of pre-filled next buffer
		s.ipos = 1                     // move to beginning of internal buffer

		// request next fill to be prepared

    assertEquals(11, queue.capacity());
    checkUnbounded(queue);
    assertSame(SOME_COMPARATOR, queue.comparator());
  }

  // We use the rawtypeToWildcard "cast" to make the test work with J2KT in other tests. Leaving one
  // test without that cast to verify that using the raw Comparable works outside J2KT.
  @J2ktIncompatible // J2KT's translation of raw Comparable is not a supertype of Int translation

      sink.writeInt(payload2)
      sink.flush()
    }
  }

  /**
   * Tell the peer to stop creating streams and that we last processed `lastGoodStreamId`, or zero
   * if no streams were processed.
   *
   * @param lastGoodStreamId the last stream ID processed, or zero if no streams were processed.
   * @param errorCode reason for closing the connection.

  map<string, string> attachmentMetadata = 2;

  // attachError represents the last error encountered during attach operation, if any.
  // This field must only be set by the entity completing the attach
  // operation, i.e. the external-attacher.
  // +optional
  optional VolumeError attachError = 3;

  // detachError represents the last error encountered during detach operation, if any.

     * to the object graph below this root, using either 'getXXX()' or 'isXXX()'
     * accessor types to resolve the value for each successive expression part.
     * Finally, return the result of the last expression part's resolution.</p>
     *
     * <p><b>NOTE:</b> The object-graph nagivation actually takes place via the
     * {@link ReflectionValueExtractor} class.</p>
     */

	relTag = relPrefix + "." + relTag
	if relSuffix != "" {
		relTag += "." + relSuffix
	}

	return relTag, t
}

// commitID returns the abbreviated commit-id hash of the last commit.
func commitID() string {
	// git log --format="%H" -n1
	var (
		commit []byte
		err    error
	)
	cmdName := "git"
	cmdArgs := []string{"log", "--format=%H", "-n1"}

Note that the go_darwin_$GOARCH_exec wrapper uninstalls any existing app identified by
the bundle id before installing a new app. If the uninstalled app is the last app by
the developer identity, the device might also remove the permission to run apps from
that developer, and the exec wrapper will fail to install the new app. To avoid that,

 *   <li>least-recently-used eviction when a maximum size is exceeded (note that the cache is
 *       divided into segments, each of which does LRU internally)
 *   <li>time-based expiration of entries, measured since last access or last write
 *   <li>keys automatically wrapped in {@code WeakReference}
 *   <li>values automatically wrapped in {@code WeakReference} or {@code SoftReference}
 *   <li>notification of evicted (or otherwise removed) entries