code: @Deprecated
    public static <K, V> ImmutableMap<K, V> disjointUnion(Map<K, V> first, Map<K, V> second) {
      checkNotNull(first);
      checkNotNull(second);
      final ImmutableMap.Builder<K, V> ret = ImmutableMap.builder();
  
      // will throw an exception if there is any null mapping
      ret.putAll(first);
      for (final Entry<K, V> secondEntry : second.entrySet()) {
        final V firstForKey = first.get(secondEntry.getKey());
        if (firstForKey == null) {
          // non-duplicate
          // we know the first map doesn't actually map this key to null
          // or ret.putAll(first) above would fail
          ret.put(secondEntry.getKey(), secondEntry.getValue());
        } else //noinspection StatementWithEmptyBody
          if (firstForKey.equals(secondEntry.getValue())) {
            // duplicate. This is okay. Do nothing.
          } else {
            throw new RuntimeException("When attempting a disjoint map union, " +
                String.format("for key %s, first map had %s but second had %s", secondEntry.getKey(),
                    firstForKey, secondEntry.getValue()));
          }
      }
  
      return ret.build();
    }
docs: Returns a new map which is contains all the mappings in both provided maps. This method will
  throw an exception if there is any key {@code K} such that {@code K} is a key in both maps and
  {@code !first.get(K).equals(second.get(K))}.    The iteration order of the resulting map will
  contain first all entries in the first map in the order provided by {@code first.entrySet()}
  followed by all non-duplicate entries in the second map in the order provided by {@code
  second.entrySet()}.  This method is null-intolerant: if either input map contains {@code null},
  an exception will be thrown.
  
  @deprecated There is no reason to use this instead of {@code
  ImmutableMap.builder().putAll(first).putAll(second).build()}