checkPositionIndexes(off, off + len, buf.length);

          int i = off;
          for (; i < off + len; i++) {
            int b = read();
            if (b == -1) {
              int read = i - off;
              return read == 0 ? -1 : read;
            }
            buf[i] = (byte) b;
          }
          return i - off;
        }

        @Override

    }

    public void execute() {
      RunnableExecutorPair stack;
      do {
        stack = head;
        if (stack == null) {
          // If head == null then execute() has been called so we should just return
          return;
        }
        // try to swap null into head.
      } while (!UNSAFE.compareAndSwapObject(this, HEAD_OFFSET, stack, null));

   *
   * @param file the file to read
   * @param processor the object to which the bytes of the file are passed.
   * @return the result of the byte processor
   * @throws IOException if an I/O error occurs
   * @deprecated Prefer {@code asByteSource(file).read(processor)}.
   */
  @Deprecated
  @InlineMe(
      replacement = "Files.asByteSource(file).read(processor)",
      imports = "com.google.common.io.Files")

    assertTrue(Arrays.equals(I18N.getBytes(Charsets.UTF_8), Files.toByteArray(i18nFile)));
    assertTrue(Arrays.equals(I18N.getBytes(Charsets.UTF_8), Files.asByteSource(i18nFile).read()));
  }

  /** A {@link File} that provides a specialized value for {@link File#length()}. */
  private static class BadLengthFile extends File {

    private final long badLength;

                  }
                  /*
                   * Also look up an earlier node so that, if the graph is using MapRetrievalCache,
                   * we read one of the fields declared in that class.
                   */
                  Set<Integer> unused = graph.successors(first);
                  return null;
                }
              }));
    }

    Node<K, V> head;
    Node<K, V> tail;
    int count;

    KeyList(Node<K, V> firstNode) {
      this.head = firstNode;
      this.tail = firstNode;
      firstNode.previousSibling = null;
      firstNode.nextSibling = null;
      this.count = 1;
    }
  }

  @CheckForNull private transient Node<K, V> head; // the head for all keys

 * read-write locks. Conceptually, lock striping is the technique of dividing a lock into many
 * <i>stripes</i>, increasing the granularity of a single lock and allowing independent operations
 * to lock different stripes and proceed concurrently, instead of creating contention for a single
 * lock.
 *
 * <p>The guarantee provided by this class is that equal keys lead to the same lock (or semaphore),

    return CollectCollectors.toMultiset(elementFunction, countFunction, multisetSupplier);
  }

  /**
   * Returns an unmodifiable view of the specified multiset. Query operations on the returned
   * multiset "read through" to the specified multiset, and attempts to modify the returned multiset
   * result in an {@link UnsupportedOperationException}.
   *

   *
   * <p>The recommended solution for finding the {@code minimum} of some values depends on the type
   * of your data and the number of elements you have. Read more in the Guava User Guide article on
   * <a href="https://github.com/google/guava/wiki/CollectionUtilitiesExplained#comparators">{@code
   * Comparators}</a>.
   *

   *     RuntimeException(e)}. But consider whether users would be better off if your API threw a
   *     different type of exception. For background on the deprecation, read <a
   *     href="https://goo.gl/Ivn2kc">Why we deprecated {@code Throwables.propagate}</a>.
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible
  @Deprecated