? null
                : location.getLocations().entrySet().stream()
                        .collect(Collectors.toMap(
                                e -> e.getKey(),
                                e -> e.getValue() == location ? this : new InputLocation(e.getValue())));
        this.importedFrom = location.getImportedFrom() != null ? new InputLocation(location.getImportedFrom()) : null;
    }

        "Should not contain null after unsupported putIfAbsent(present, null)");
  }

  @CanIgnoreReturnValue
  private V putIfAbsent(Entry<K, V> entry) {
    return getMap().putIfAbsent(entry.getKey(), entry.getValue());
  }

  /** 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();

  /*
   * Used by entries that use access order. Access entries are maintained in a doubly-linked list.
   * New entries are added at the tail of the list at write time; stale entries are expired from

        String ret = this.proto + ":" + this.server + "[" + this.endpoint;
        if ( this.options != null ) {
            for ( Entry<String, Object> entry : this.options.entrySet() ) {
                ret += "," + entry.getKey() + "=" + entry.getValue();
            }
        }
        ret += "]";
        return ret;
    }

                    for (Object object : elements) {
                      Entry<Class, Impl> entry = (Entry<Class, Impl>) object;
                      map.putInstance(entry.getKey(), entry.getValue());
                    }
                    return (Map) map;
                  }
                })
            .named("MutableClassToInstanceMap")
            .withFeatures(

    public Builder<K, V> putAll(Multimap<? extends K, ? extends V> multimap) {
      for (Entry<? extends K, ? extends Collection<? extends V>> entry :
          multimap.asMap().entrySet()) {
        putAll(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    Builder<K, V> combine(ImmutableMultimap.Builder<K, V> other) {
      super.combine(other);

      count.incrementAndGet();
      lastNotification = notification;
    }

    public int getCount() {
      return count.get();
    }

    public K getLastEvictedKey() {
      return lastNotification.getKey();
    }

    public V getLastEvictedValue() {
      return lastNotification.getValue();
    }

    public RemovalNotification<K, V> getLastNotification() {
      return lastNotification;
    }
  }

  }

  @Override
  public boolean contains(@CheckForNull Object object) {
    return map.containsKey(object);
  }

  @Override
  K get(int index) {
    return map.entrySet().asList().get(index).getKey();
  }

  @Override
  public void forEach(Consumer<? super K> action) {
    checkNotNull(action);
    map.forEach((k, v) -> action.accept(k));
  }

  @Override
  boolean isPartialView() {

            protected N computeNext() {
              while (entries.hasNext()) {
                Entry<N, Object> entry = entries.next();
                if (isPredecessor(entry.getValue())) {
                  return entry.getKey();
                }
              }
              return endOfData();
            }
          };
        } else {
          Iterator<NodeConnection<N>> nodeConnections = orderedNodeConnections.iterator();

            elementStack.addFirst(name);
            visitor.onStartHtmlElement(name);
            for (Map.Entry<String, String> entry : attributes.entrySet()) {
                visitor.onHtmlElementAttribute(entry.getKey(), entry.getValue());
            }
            attributes.clear();
            visitor.onStartHtmlElementComplete(name);
        }

        @Override
        public void onEndHtmlElement(String name) {