protected Iterator<E> standardIterator() {
    return Multisets.iteratorImpl(this);
  }

  /**
   * A sensible, albeit inefficient, definition of {@link #size} in terms of {@link #entrySet}. If
   * you override {@link #entrySet}, you may wish to override {@link #size} to forward to this
   * implementation.
   *
   * @since 7.0
   */
  protected int standardSize() {
    return Multisets.linearTimeSizeImpl(this);
  }

          return rangeMapEntry.getValue();
        }
      }
      return null;
    }

    @Override
    public int size() {
      return entriesByLowerBound.size();
    }

    @Override
    Iterator<Entry<Range<K>, V>> entryIterator() {
      return entryIterable.iterator();
    }
  }

  @Override

        return new VersionRange(version, restrictions);
    }

    private List<Restriction> intersection(List<Restriction> r1, List<Restriction> r2) {
        List<Restriction> restrictions = new ArrayList<>(r1.size() + r2.size());
        Iterator<Restriction> i1 = r1.iterator();
        Iterator<Restriction> i2 = r2.iterator();
        Restriction res1 = i1.next();
        Restriction res2 = i2.next();

        boolean done = false;

            }
            if (!smb1AuthList.isEmpty()) {
                factoryParamMap.put(org.codelibs.fess.crawler.client.smb1.SmbClient.SMB_AUTHENTICATIONS_PROPERTY,
                        smb1AuthList.toArray(new org.codelibs.fess.crawler.client.smb1.SmbAuthentication[smb1AuthList.size()]));
            }
            if (!ftpAuthList.isEmpty()) {

        title.appendChild(document.createTextNode("("));
        List<ParameterMetaData> parameters = methodDoc.getMetaData().getParameters();
        for (int i = 0; i < parameters.size(); i++) {
            ParameterMetaData param = parameters.get(i);
            if (i > 0) {
                title.appendChild(document.createTextNode(", "));
            }

                }
                responseData.addMetaData(SMB_ALLOWED_SID_ENTRIES, sidAllowSet.toArray(new SID[sidAllowSet.size()]));
                responseData.addMetaData(SMB_DENIED_SID_ENTRIES, sidDenySet.toArray(new SID[sidDenySet.size()]));
            }
        } catch (final IOException e) {
            throw new CrawlingAccessException("Could not access " + file.getPath(), e);
        }

  }

  /**
   * Returns the number of elements in this fluent iterable.
   *
   * <p><b>{@code Stream} equivalent:</b> {@code stream.count()}.
   */
  public final int size() {
    return Iterables.size(getDelegate());
  }

  /**
   * Returns {@code true} if this fluent iterable contains any object for which {@code
   * equals(target)} is true.
   *

 * classes and the classes they depend on. The classes are not relocated, they all
 * remain in their original namespace. This reduces the final Gradle distribution
 * size and makes us more conscious of which parts of a library we really need.
 */
val keepPatterns = mapOf(
    "fastutil" to setOf(
        // For Java compilation incremental analysis

          explode: true
          schema:
            type: array
            items:
              type: string
            example: ["timestamp:[now/d-1d TO *]"]
        - name: facet.size
          in: query
          description: Item size in facets returned by facet.field
          required: false
          schema:
            type: integer
            minimum: 0
            exclusiveMinimum: false

          "10000003b00102a032880f0290011faceb00c00000002",
      ),
    )
    dns = buildLocalhost(bootstrapClient, true)
    val result = dns.lookup("google.com")
    assertThat(result.size).isEqualTo(2)
    assertThat(result).contains(address("157.240.1.18"))
    assertThat(result).contains(address("2a03:2880:f029:11:face:b00c:0:2"))
    val request1 = server.takeRequest()