Map.Entry<?, ?> entry = tryConvertingToEntry(o);
        if (entry == null) {
            return null;
        }
        // Return a copy to make sure that the results of getKey() and getValue() do not change.
        Object key = entry.getKey();
        Object value = entry.getValue();
        if (key instanceof String && value instanceof String) {
            return Maps.immutableEntry((String) key, (String) value);
        }

        && entry.getValue().getKey().isConnected(range)
        && entry.getValue().getValue().equals(value)) {
      return range.span(entry.getValue().getKey());
    }
    return range;
  }

  @Override
  public void putAll(RangeMap<K, ? extends V> rangeMap) {
    for (Entry<Range<K>, ? extends V> entry : rangeMap.asMapOfRanges().entrySet()) {
      put(entry.getKey(), entry.getValue());
    }
  }

            if (o instanceof Entry && MapPropertyMapView.this.containsKey(((Entry<?, ?>) o).getKey())) {
                Entry<?, ?> entry = (Entry<?, ?>) o;
                V value = MapPropertyMapView.this.get(entry.getKey());
                if (Objects.equals(value, entry.getValue())) {
                    MapPropertyMapView.this.remove(entry.getKey());
                    return true;
                }
            }

            builder.add(new MapEntrySnapshot<ValueSnapshot>(entry.getKey().asSnapshot(), entry.getValue().asSnapshot()));
        }
        return new MapValueSnapshot(builder.build());
    }

    @Override
    public T isolate() {
        T map = create();
        for (MapEntrySnapshot<Isolatable<?>> entry : getEntries()) {
            map.put(entry.getKey().isolate(), entry.getValue().isolate());
        }
        return map;

        Objects.requireNonNull(model, "model cannot be null");

        ClassLoader parent = getMavenApiRealm();

        return createRealm(getKey(model), RealmType.Project, parent, null, null, artifacts);
    }

    private static String getKey(Model model) {
        return "project>" + model.getGroupId() + ":" + model.getArtifactId() + ":" + model.getVersion();
    }

            });
    List<Entry<K, V>> expectedEntries = new ArrayList<>();
    for (Entry<K, V> entry : getSampleEntries()) {
      int index = keys().asList().indexOf(entry.getKey());
      expectedEntries.add(Helpers.mapEntry(entry.getKey(), values().asList().get(index + 1)));
    }
    expectContents(expectedEntries);
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionFeature.Require(KNOWN_ORDER)

    public int compare(Entry<K, V> a, Entry<K, V> b) {
      return (keyComparator == null)
          ? ((Comparable) a.getKey()).compareTo(b.getKey())
          : keyComparator.compare(a.getKey(), b.getKey());
    }
  }

  public static <K extends @Nullable Object, V extends @Nullable Object>

                logger.debug("--- init fork of " + fork.getKey() + " for " + mojoExecId + " ---");

                debugDependencyRequirements(fork.getValue());

                for (MojoExecution forkedExecution : fork.getValue()) {
                    debugMojoExecution(forkedExecution);
                }

                logger.debug("--- exit fork of " + fork.getKey() + " for " + mojoExecId + " ---");
            }
        }

  return getKey().str();
}

std::optional<std::string> _XlaRecvAtHostV2Op::GetResourceInstanceStr() {
  return getKey().str();
}

std::optional<std::string> _XlaSendFromHostOp::GetResourceInstanceStr() {
  return getKey().str();
}

std::optional<std::string> _XlaSendFromHostV2Op::GetResourceInstanceStr() {
  return getKey().str();
}

namespace {

            sv.setUpdated(lastUpdated);

            versions.put(getKey(sv.getClassifier(), sv.getExtension()), sv);
        }

        artifacts.clear();

        Versioning versioning = recessive.getVersioning();
        if (versioning != null) {
            for (SnapshotVersion sv : versioning.getSnapshotVersions()) {
                String key = getKey(sv.getClassifier(), sv.getExtension());