dst.Add(t)
		return true
	})
	return
}

type MapSet[T any] struct {
	m a.Map[T, struct{}]
}

func HashSet[T comparable](capacity int) MapSet[T] {
	return FromMap[T](a.NewHashMap[T, struct{}](capacity))
}

func FromMap[T any](m a.Map[T, struct{}]) MapSet[T] {
	return MapSet[T]{
		m: m,
	}
}

func (s MapSet[T]) Add(t T) {
	s.m.Put(t, struct{}{})
}

        Map<String, String> featureMap = newHashMap();
        featureMap.put("http://xml.org/sax/features/namespaces", "false");
        fileTransformer.setFeatureMap(featureMap);
        Map<String, String> propertyMap = newHashMap();
        fileTransformer.setPropertyMap(propertyMap);
        Map<String, String> childUrlRuleMap = newHashMap();
        childUrlRuleMap.put("//A", "href");

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.lang;

import static org.codelibs.core.collection.CollectionsUtil.newHashMap;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.lang.annotation.Annotation;
import java.util.Map;

import org.codelibs.core.beans.BeanDesc;

        }
        if (getExcludeSpecs() != null) {
            copy.setExcludeSpecs(Sets.newHashSet(getExcludeSpecs()));
        }
        if (getRequiredAttributes() != null) {
            copy.setRequiredAttributes(Maps.newHashMap(getRequiredAttributes()));
        }
        return copy;
    }

	return Pair[L, R]{L: l, R: r}
}

type Map[K, V any] interface {
	Put(K, V)
	Len() int
	Iterate(func(Pair[K, V]) bool)
}

type HashMap[K comparable, V any] struct {
	m map[K]V
}

func NewHashMap[K comparable, V any](capacity int) HashMap[K, V] {
	var m map[K]V
	if capacity >= 1 {
		m = make(map[K]V, capacity)
	} else {
		m = map[K]V{}
	}

	return HashMap[K, V]{m: m}
}

        }
        return actual;
    }

    @Override
    public void setEnvironment(Map<String, ?> environmentVariables) {
        environment = Maps.newHashMap(environmentVariables);
    }

    @Override
    public ProcessForkOptions environment(String name, Object value) {
        getEnvironment().put(name, value);
        return this;
    }

  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();
    int distinctElements = Serialization.readCount(stream);
    setBackingMap(Maps.<E, Count>newHashMap());
    Serialization.populateMultiset(this, stream, distinctElements);
  }

  @GwtIncompatible // Not needed in emulated source.
  @J2ktIncompatible
  private static final long serialVersionUID = 0;

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.io;

import static org.codelibs.core.collection.CollectionsUtil.newHashMap;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.util.Enumeration;
import java.util.Locale;

        noClasses()
            .should()
            .callMethod(com.google.common.collect.Maps.class, "newConcurrentMap")
            .orShould()
            .callMethod(com.google.common.collect.Maps.class, "newHashMap")
            .orShould()
            .callMethod(com.google.common.collect.Maps.class, "newLinkedHashMap")
            .orShould()
            .callMethod(com.google.common.collect.Maps.class, "newIdentityHashMap")

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.net;

import static org.codelibs.core.collection.ArrayUtil.asArray;
import static org.codelibs.core.collection.CollectionsUtil.newHashMap;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.io.File;
import java.io.IOException;