@media only screen and (max-width: 420px) {
a[class="article-headline"] {
font-size:22px !important;
line-height:28px !important;
}
td[class="story-attribution"]{
font-size: 13px !important;
}
td[class="context"]{
-webkit-text-size-adjust:none !important;
font-size: 12px !important;
}
a[class="action"]{
-webkit-text-size-adjust:none !important;
font-size: 12px !important;
}
td[class="margins"]{
width:15px !important;
}

        }
        final int size = Encdec.dec_uint16be(this.sbuf, 2) & 0xFFFF;
        if (size < 33 || 4 + size > this.sbuf.length) {
            throw new IOException("Invalid payload size: " + size);
        }
        final int hdrSize = this.smb2 ? Smb2Constants.SMB2_HEADER_LENGTH : SMB1_HEADER_LENGTH;
        readn(this.in, this.sbuf, 4 + hdrSize, size - hdrSize);
        log.trace("Read negotiate response");

   */
  public static <E> Set<Set<E>> combinations(Set<E> set, int size) {
    ImmutableMap<E, Integer> index = Maps.indexMap(set);
    checkNonnegative(size, "size");
    checkArgument(size <= index.size(), "size (%s) must be <= set.size() (%s)", size, index.size());
    if (size == 0) {
      return ImmutableSet.of(ImmutableSet.of());
    } else if (size == index.size()) {
      return ImmutableSet.of(index.keySet());
    }

    createNewCacheWithSize(10)
    set("a", "a", "aaa") // size 4
    set("b", "bb", "bbbb") // size 6
    cache.maxSize = 20
    set("c", "c", "c") // size 12
    assertThat(cache.size()).isEqualTo(12)
  }

  @Test
  fun shrinkMaxSizeEvicts() {
    cache.close()
    createNewCacheWithSize(20)
    set("a", "a", "aaa") // size 4
    set("b", "bb", "bbbb") // size 6
    set("c", "c", "c") // size 12

indexer.webfs.update.interval=10000
# Maximum document cache size for webfs in the indexer.
indexer.webfs.max.document.cache.size=10
# Maximum document request size (bytes) for webfs in the indexer.
indexer.webfs.max.document.request.size=1048576
# Maximum document cache size for data in the indexer.
indexer.data.max.document.cache.size=10000
# Maximum document request size (bytes) for data in the indexer.

    for (int size = 1; size < 200; size++) {
      assertWontGrow(
          size,
          new LinkedHashMap<>(),
          Maps.newLinkedHashMapWithExpectedSize(size),
          Maps.newLinkedHashMapWithExpectedSize(size));
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  private static void assertWontGrow(
      int size,
      HashMap<Object, Object> referenceMap,

        this.maximumSize == UNSET_INT, "maximum size was already set to %s", this.maximumSize);
    checkState(
        this.maximumWeight == UNSET_INT,
        "maximum weight was already set to %s",
        this.maximumWeight);
    checkState(this.weigher == null, "maximum size can not be combined with weigher");
    checkArgument(maximumSize >= 0, "maximum size must not be negative");
    this.maximumSize = maximumSize;

    Builder<K, V> combine(ImmutableSortedMap.Builder<K, V> other) {
      ensureCapacity(size + other.size);
      System.arraycopy(other.keys, 0, this.keys, this.size, other.size);
      System.arraycopy(other.values, 0, this.values, this.size, other.size);
      size += other.size;
      return this;
    }

    /**
     * Returns a newly-created immutable sorted map.
     *

        if (siteValue != null) {
            final String site = siteValue.toString();
            final int size = fessConfig.getResponseMaxSitePathLengthAsInteger();
            if (size > 3) {
                return StringUtils.abbreviate(site, size);
            }
            if (size >= 0) {
                return site;
            }
        }

    for (int size = 1; size < 200; size++) {
      assertWontGrow(
          size,
          new LinkedHashMap<>(),
          Maps.newLinkedHashMapWithExpectedSize(size),
          Maps.newLinkedHashMapWithExpectedSize(size));
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  private static void assertWontGrow(
      int size,
      HashMap<Object, Object> referenceMap,