ServerMessageBlock2Request<?> n = getNext();
        if ( n != null ) {
            setNext(null);
            n.clearFlags(SMB2_FLAGS_RELATED_OPERATIONS);
        }
        return n;
    }


    /**
     * 
     * @param next
     */
    public void setNext ( ServerMessageBlock2Request<?> next ) {
        super.setNext(next);
    }


    /**
     * {@inheritDoc}

            final ByteArrayOutputStream value = new ByteArrayOutputStream();
            streams.put(segmentChunk, value);
            printStreams.put(segmentChunk, new PrintStream(value));
        }
        setNext();
        this.originalSystemOUtStream = originalSystemOut;
        System.setOut(new ThreadBoundPrintStream(this.originalSystemOUtStream));
        printer = new ConsolePrinter(segmentChunks);

      ATOMIC_HELPER.putThread(this, Thread.currentThread());
    }

    // non-volatile write to the next field. Should be made visible by subsequent CAS on waiters
    // field.
    void setNext(@CheckForNull Waiter next) {
      ATOMIC_HELPER.putNext(this, next);
    }

    void unpark() {
      // This is racy with removeWaiter. The consequence of the race is that we may spuriously call

        }

        n.addFlags(SMB2_FLAGS_RELATED_OPERATIONS);
        this.next = n;
        return true;
    }


    protected ServerMessageBlock2 getNext () {
        return this.next;
    }


    protected void setNext ( ServerMessageBlock2 n ) {
        this.next = n;
    }


    /**
     * @return the response
     */
    @Override

     */
    @GuardedBy("this")
    @CheckForNull
    E removeFromChain(E first, E entry) {
      int newCount = count;
      E newFirst = entry.getNext();
      for (E e = first; e != entry; e = e.getNext()) {
        E next = copyEntry(e, newFirst);
        if (next != null) {
          newFirst = next;
        } else {
          newCount--;
        }
      }

   * wish to override {@link #lower} to forward to this implementation.
   */
  @CheckForNull
  protected E standardLower(@ParametricNullness E e) {
    return Iterators.getNext(headSet(e, false).descendingIterator(), null);
  }

  @Override
  @CheckForNull
  public E floor(@ParametricNullness E e) {
    return delegate().floor(e);
  }

  /**

        if (CompactHashing.getHashPrefix(entry, mask) == hashPrefix
            && Objects.equal(object, elements[entryIndex])) {
          return false;
        }
        next = CompactHashing.getNext(entry, mask);
        bucketLength++;
      } while (next != UNSET);

      if (bucketLength >= MAX_HASH_BUCKET_LENGTH) {
        return convertToHashFloodingResistantImplementation().add(object);
      }

     */
    @Override
    public boolean isResponseAsync () {
        return false;
    }


    @Override
    public ServerMessageBlock2Request<?> getNext () {
        return null;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#getOverrideTimeout()
     */
    @Override

  /** Sets the value reference for this entry. */
  void setValueReference(ValueReference<K, V> valueReference);

  /** Returns the next entry in the chain. */
  @CheckForNull
  ReferenceEntry<K, V> getNext();

  /** Returns the entry's hash. */
  int getHash();

  /** Returns the key for this entry. */
  @CheckForNull
  K getKey();

  /*

     *
     * @see jcifs.internal.CommonServerMessageBlockResponse#getNextResponse()
     */
    @Override
    public CommonServerMessageBlockResponse getNextResponse () {
        return (CommonServerMessageBlockResponse) getNext();
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockResponse#prepare(jcifs.internal.CommonServerMessageBlockRequest)
     */
    @Override