// dataUsageCacheV2 contains a cache of data usage entries version 2.
type dataUsageCacheV2 struct {
	Info  dataUsageCacheInfo
	Cache map[string]dataUsageEntryV2
}

// dataUsageCacheV3 contains a cache of data usage entries version 3.
type dataUsageCacheV3 struct {
	Info  dataUsageCacheInfo
	Cache map[string]dataUsageEntryV3
}

// dataUsageCacheV4 contains a cache of data usage entries version 4.

   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.filter(predicate).findFirst()}.
   */
  public final Optional<@NonNull E> firstMatch(Predicate<? super E> predicate) {
    // Unsafe, but we can't do much about it now.
    return Iterables.<@NonNull E>tryFind((Iterable<@NonNull E>) getDelegate(), predicate);
  }

  /**

   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.filter(predicate).findFirst()}.
   */
  public final Optional<@NonNull E> firstMatch(Predicate<? super E> predicate) {
    // Unsafe, but we can't do much about it now.
    return Iterables.<@NonNull E>tryFind((Iterable<@NonNull E>) getDelegate(), predicate);
  }

  /**

import com.google.common.annotations.GwtCompatible;
import com.google.common.base.Supplier;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Source of {@link LongAddable} objects that deals with GWT, Unsafe, and all that.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class LongAddables {
  private static final Supplier<LongAddable> SUPPLIER;

  static {
    Supplier<LongAddable> supplier;
    try {

    }
  }

  // Unsafe, see ImmutableSortedSetFauxverideShim.
  @SuppressWarnings("unchecked")
  public static <E> ImmutableSortedSet<E> copyOf(Collection<? extends E> elements) {
    return copyOfInternal((Ordering<E>) Ordering.natural(), (Collection<E>) elements, false);
  }

  // Unsafe, see ImmutableSortedSetFauxverideShim.
  @SuppressWarnings("unchecked")

     * package-private, I feel OK with just not testing them for NPE.
     *
     * Note that testing casValue is particularly dangerous because it uses Unsafe under some
     * versions of Java, and apparently Unsafe can cause SIGSEGV instead of NPE—almost as if it's
     * not safe.
     */
    concat(
            stream(AbstractFuture.class.getDeclaredMethods()),

    return Collectors.collectingAndThen(
        Collectors.toMap(
            keyFunction, valueFunction, mergeFunction, () -> new TreeMap<K, V>(comparator)),
        ImmutableSortedMap::copyOfSorted);
  }

  // unsafe, comparator() returns a comparator on the specified type
  @SuppressWarnings("unchecked")
  public static <K, V> ImmutableSortedMap<K, V> of() {
    return new Builder<K, V>((Comparator<K>) NATURAL_ORDER).build();
  }

    static {
      Unsafe unsafe = null;
      try {
        unsafe = Unsafe.getUnsafe();
      } catch (SecurityException tryReflectionInstead) {
        try {
          unsafe =
              doPrivileged(
                  (PrivilegedExceptionAction<Unsafe>)
                      () -> {
                        Class<Unsafe> k = Unsafe.class;

    static {
      Unsafe unsafe = null;
      try {
        unsafe = Unsafe.getUnsafe();
      } catch (SecurityException tryReflectionInstead) {
        try {
          unsafe =
              doPrivileged(
                  (PrivilegedExceptionAction<Unsafe>)
                      () -> {
                        Class<Unsafe> k = Unsafe.class;

     */
    public static byte[] calculateMacHMACAES(int usage, KerberosKey baseKey, byte[] input) throws GeneralSecurityException {
        byte[] cst = { (byte) (usage >> 24 & 0xFF), (byte) (usage >> 16 & 0xFF), (byte) (usage >> 8 & 0xFF), (byte) (usage & 0xFF),
                (byte) 0x99 };

        byte[] output = new byte[12];
        byte[] dk = deriveKeyAES(baseKey, cst); // Checksum key