}
                }
            }
        }

        return itemList;
    }

    protected boolean matchLocale(final Locale requestLocale, final Locale targetLocale) {
        if (targetLocale.equals(requestLocale) || targetLocale.equals(Locale.ROOT)) {
            return true;
        }
        if (requestLocale == null || !requestLocale.getLanguage().equals(targetLocale.getLanguage())

          }
          return true;
        }
      }
    }
    return false;
  }

  // Views

  @Override
  Set<E> createElementSet() {
    Set<E> delegate = countMap.keySet();
    return new ForwardingSet<E>() {
      @Override
      protected Set<E> delegate() {
        return delegate;
      }

      @Override

      return delegate;
    }

    public final Bound getTo() {
      return to;
    }

    public final Bound getFrom() {
      return from;
    }

    @Override
    public SampleElements<E> samples() {
      return delegate.samples();
    }

    @Override
    public E[] createArray(int length) {
      return delegate.createArray(length);
    }

    }

    public String getNewInput() {
        return newInput;
    }

    public void setNewInput(final String newInput) {
        this.newInput = newInput;
    }

    public String getInput() {
        return input;
    }

    public String getInputValue() {
        if (input == null) {
            return StringUtil.EMPTY;
        }
        return input;
    }

    public boolean isUpdated() {

-A ISTIO_INBOUND -p tcp --dport 15020 -j RETURN
-A ISTIO_INBOUND -p tcp --dport 15021 -j RETURN
-A ISTIO_INBOUND -p tcp --dport 15090 -j RETURN
-A ISTIO_INBOUND -p tcp -m conntrack --ctstate RELATED,ESTABLISHED -j ISTIO_DIVERT
-A ISTIO_INBOUND -p tcp -j ISTIO_TPROXY
-A PREROUTING -p tcp -m mark --mark 1337 -j CONNMARK --save-mark
-A OUTPUT -p tcp -o lo -m mark --mark 1337 -j RETURN

     */
    public String getEndpoint () {
        return this.endpoint;
    }


    /**
     * @return the uuid
     */
    UUID getUuid () {
        return this.uuid;
    }


    /**
     * @return the major
     */
    int getMajor () {
        return this.major;
    }


    /**
     * @return the minor
     */
    int getMinor () {

    }
    return result;
  }

  @WeakOuter
  class EntrySet extends Multisets.EntrySet<E> {
    @Override
    Multiset<E> multiset() {
      return AbstractMultiset.this;
    }

    @Override
    public Iterator<Entry<E>> iterator() {
      return entryIterator();
    }

    @Override
    public int size() {
      return distinctElements();
    }
  }

func (ssecCopy) IsRequested(h http.Header) bool {
	if _, ok := h[xhttp.AmzServerSideEncryptionCopyCustomerAlgorithm]; ok {
		return true
	}
	if _, ok := h[xhttp.AmzServerSideEncryptionCopyCustomerKey]; ok {
		return true
	}
	if _, ok := h[xhttp.AmzServerSideEncryptionCopyCustomerKeyMD5]; ok {
		return true
	}
	return false
}

// ParseHTTP parses the SSE-C copy headers and returns the SSE-C client key

    }


    /**
     * @return the request
     */
    public SmbNegotiationRequest getRequest () {
        return this.request;
    }


    /**
     * @return the response
     */
    public SmbNegotiationResponse getResponse () {
        return this.response;
    }


    /**
     * @return the negoReqBuffer
     */
    public byte[] getRequestRaw () {

      return buildOrThrow();
    }

    @Override
    public ImmutableBiMap<K, V> buildOrThrow() {
      ImmutableMap<K, V> map = super.buildOrThrow();
      if (map.isEmpty()) {
        return of();
      }
      return new RegularImmutableBiMap<K, V>(super.buildOrThrow());
    }

    @Override
    ImmutableBiMap<K, V> buildJdkBacked() {
      return build();
    }
  }