}

  @Override
  public final boolean hasPrevious() {
    return backingIterator().hasPrevious();
  }

  @Override
  @ParametricNullness
  public final T previous() {
    return transform(backingIterator().previous());
  }

  @Override
  public final int nextIndex() {
    return backingIterator().nextIndex();
  }

  @Override
  public final int previousIndex() {

  }

  @Override
  public final boolean hasPrevious() {
    return backingIterator().hasPrevious();
  }

  @Override
  @ParametricNullness
  public final T previous() {
    return transform(backingIterator().previous());
  }

  @Override
  public final int nextIndex() {
    return backingIterator().nextIndex();
  }

  @Override
  public final int previousIndex() {

                ret.add(v.label);
                return ret;
            }
        }
        return null;
    }

    static class Vertex {
        final String label;
        final List<Vertex> children = new ArrayList<>();
        final List<Vertex> parents = new ArrayList<>();

        Vertex(String label) {
            this.label = label;
        }

        String getLabel() {

  }

  private static final class Sha1Holder {
    static final HashFunction SHA_1 = new MessageDigestHashFunction("SHA-1", "Hashing.sha1()");
  }

  /** Returns a hash function implementing the SHA-256 algorithm (256 hash bits). */
  public static HashFunction sha256() {
    return Sha256Holder.SHA_256;
  }

  private static final class Sha256Holder {
    static final HashFunction SHA_256 =

        : new ArrayTable<R, C, V>(table);
  }

  private final ImmutableList<R> rowList;
  private final ImmutableList<C> columnList;

  // TODO(jlevy): Add getters returning rowKeyToIndex and columnKeyToIndex?
  private final ImmutableMap<R, Integer> rowKeyToIndex;
  private final ImmutableMap<C, Integer> columnKeyToIndex;
  private final @Nullable V[][] array;

    private static final Logger log = LoggerFactory.getLogger(PersistentHandleManager.class);

    private final ConcurrentHashMap<String, HandleInfo> handles;
    private final ConcurrentHashMap<HandleGuid, HandleInfo> guidToHandle;
    private final Path stateDirectory;
    private final ScheduledExecutorService scheduler;
    private final CIFSContext context;

   * account for that -- while not doing any extra work if the value has not moved.
   */
  static final class EntryForValue<K extends @Nullable Object, V extends @Nullable Object>
      extends AbstractMapEntry<V, K> {
    final HashBiMap<K, V> obverse;
    @ParametricNullness final V obverseValue;
    int index;

    EntryForValue(HashBiMap<K, V> obverse, int index) {
      this.obverse = obverse;

     *
     * @param value the hyper integer value
     */
    public NdrHyper(final long value) {
        this.value = value;
    }

    @Override
    public void encode(final NdrBuffer dst) throws NdrException {
        dst.enc_ndr_hyper(value);
    }

    @Override
    public void decode(final NdrBuffer src) throws NdrException {
        value = src.dec_ndr_hyper();
    }

     *
     * @param value the long integer value
     */
    public NdrLong(final int value) {
        this.value = value;
    }

    @Override
    public void encode(final NdrBuffer dst) throws NdrException {
        dst.enc_ndr_long(value);
    }

    @Override
    public void decode(final NdrBuffer src) throws NdrException {
        value = src.dec_ndr_long();
    }

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public final class PostFile {
  public static final MediaType MEDIA_TYPE_MARKDOWN
      = MediaType.get("text/x-markdown; charset=utf-8");

  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    File file = new File("README.md");