return set1.contains(element) ^ set2.contains(element);
      }

      @Override
      int minSize() {
        int difference = minSize(set1) - maxSize(set2);
        return difference >= 0 ? difference : max(minSize(set2) - maxSize(set1), 0);
      }

      @Override
      int maxSize() {
        return saturatedAdd(maxSize(set1), maxSize(set2));
      }
    };
  }

  /**

 *
 *
 * <p>This class is intended for internal use.</p>
 */
public class BufferCacheImpl implements BufferCache {

    private final Object[] cache;
    private final int bufferSize;
    private int freeBuffers = 0;

    /**
     * Constructs a buffer cache using configuration settings.
     *
     * @param cfg the configuration to use for buffer cache settings
     */

/**
 * A collection of preconditions for math functions.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class MathPreconditions {
  @CanIgnoreReturnValue
  static int checkPositive(String role, int x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue
  static long checkPositive(String role, long x) {

      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public boolean setCount(T element, int oldCount, int newCount) {
      return standardSetCount(element, oldCount, newCount);
    }

    @Override
    public int setCount(T element, int count) {
      return standardSetCount(element, count);
    }

    getMap()
        .replaceAll(
            (K k, V v) -> {
              int index = keys().asList().indexOf(k);
              return values().asList().get(index + 1);
            });
    List<Entry<K, V>> expectedEntries = new ArrayList<>();
    for (Entry<K, V> entry : getSampleEntries()) {
      int index = keys().asList().indexOf(entry.getKey());

   * @return The number of characters consumed from {@code encoded}.
   */
  private static int doParseTrieToBuilder(
      Deque<CharSequence> stack,
      CharSequence encoded,
      int start,
      ImmutableMap.Builder<String, PublicSuffixType> builder) {

    int encodedLen = encoded.length();
    int idx = start;
    char c = '\0';

    // Read all the characters for this node.

    /**
     * Thread priority for index updater operations.
     */
    protected int indexUpdaterPriority = Thread.MAX_PRIORITY;

    /**
     * Thread priority for crawler operations.
     */
    protected int crawlerPriority = Thread.NORM_PRIORITY;

    /**
     * Synchronized list of active crawlers.
     */

                return false;
            }

            return true;
        }

        public long getDelayMs(int attemptNumber) {
            if (!exponentialBackoff) {
                return initialDelayMs;
            }

            long delay = initialDelayMs;
            for (int i = 1; i < attemptNumber; i++) {
                delay = (long) (delay * backoffMultiplier);
            }

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

    private static final int ANDX_COMMAND_OFFSET = 1;
    private static final int ANDX_RESERVED_OFFSET = 2;
    private static final int ANDX_OFFSET_OFFSET = 3;

    private byte andxCommand = (byte) 0xFF;
    private int andxOffset = 0;

    private ServerMessageBlock andx;

    /**

        byte[] dst = new byte[100];
        int dstIndex = 0;

        // Mock the superclass method to control its behavior
        doReturn(10).when((NameServicePacket) request).writeQuestionSectionWireFormat(any(byte[].class), anyInt());

        int result = request.writeBodyWireFormat(dst, dstIndex);

        // Verify that writeQuestionSectionWireFormat was called