// Path: src/main/java/ch/codebulb/lambdaomega/M.java
// public static class E<K, V> implements Comparable<E<K, V>> {
//     public final K k;
//     public final V v;
// 
//     public E(K k, V v) {
//         this.k = k;
//         this.v = v;
//     }
//         
//     public Map.Entry<K, V> toEntry() {
//         return new AbstractMap.SimpleEntry<>(k, v);
//     }
// 
//     public K getK() {
//         return k;
//     }
// 
//     public V getV() {
//         return v;
//     }
// 
//     @Override
//     public int hashCode() {
//         int hash = 7;
//         hash = 59 * hash + Objects.hashCode(this.k);
//         hash = 59 * hash + Objects.hashCode(this.v);
//         return hash;
//     }
// 
//     @Override
//     public boolean equals(Object obj) {
//         if (obj == null) {
//             return false;
//         }
//         if (getClass() != obj.getClass()) {
//             return false;
//         }
//         final E<?, ?> other = (E<?, ?>) obj;
//         if (!Objects.equals(this.k, other.k)) {
//             return false;
//         }
//         if (!Objects.equals(this.v, other.v)) {
//             return false;
//         }
//         return true;
//     }
// 
//     @Override
//     public String toString() {
//         return "e(" + k + ", " + v + ')';
//     }
// 
//     @Override
//     public int compareTo(E<K, V> obj) {
//         if (obj == null) {
//             return 1;
//         }
//             
//         if (!(k instanceof Comparable)) {
//             throw new ClassCastException(k.getClass().getName() + " cannot be cast to java.lang.Comparable");
//         }
//         int ret = ((Comparable<K>)k).compareTo(obj.k);
//         if (ret != 0) {
//             return ret;
//         }
//             
//         if (!(v instanceof Comparable)) {
//             throw new ClassCastException(v.getClass().getName() + " cannot be cast to java.lang.Comparable");
//         }
//         ret = ((Comparable<V>)v).compareTo(obj.v);
//             
//         return ret;
//     }
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/U.java
// public static <T> boolean any(Predicate<T> predicate, T... candidates) {
//     return C.toStream(candidates).anyMatch(predicate);
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/abstractions/OmegaObject.java
// public abstract class OmegaObject {
//     /**
//      * Prints itself to the standard output.
//      */
//     public void println() {
//         U.println(this);
//     }
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/abstractions/ReadonlyIndexedI.java
// public interface ReadonlyIndexedI<K, V> extends I<K, V> {
//     
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/abstractions/StreamableI.java
// public interface StreamableI {
//     /**
//      * Returns <code>true</code>, if the data structure is parallel streamed.
//      */
//     public boolean isParallel();
// }


import ch.codebulb.lambdaomega.M.E;
import static ch.codebulb.lambdaomega.U.any;
import ch.codebulb.lambdaomega.abstractions.OmegaObject;
import ch.codebulb.lambdaomega.abstractions.ReadonlyIndexedI;
import ch.codebulb.lambdaomega.abstractions.StreamableI;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Properties;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.WeakHashMap;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
                return new LinkedHashSet<T>();
            }
            if (format.isAssignableFrom(LinkedList.class)) {
                return new LinkedList<T>();
            }
            if (format.isAssignableFrom(LinkedTransferQueue.class)) {
                return new LinkedTransferQueue<T>();
            }
            if (format.isAssignableFrom(PriorityBlockingQueue.class)) {
                return new PriorityBlockingQueue<T>();
            }
            if (format.isAssignableFrom(PriorityQueue.class)) {
                return new PriorityQueue<T>();
            }
            if (format.isAssignableFrom(Stack.class)) {
                return new Stack<T>();
            }
            // TODO What about SynchronousQueue?
            if (format.isAssignableFrom(TreeSet.class)) {
                return new TreeSet<T>();
            }
            // Vector is considered "obsolete"
            
            throw new IllegalArgumentException("Return type not supported: " + format);
        }));
        }
        
        if (any(it -> format.isAssignableFrom(it), 
                ConcurrentHashMap.class,
                ConcurrentSkipListMap.class)) {
// Path: src/main/java/ch/codebulb/lambdaomega/M.java
// public static class E<K, V> implements Comparable<E<K, V>> {
//     public final K k;
//     public final V v;
// 
//     public E(K k, V v) {
//         this.k = k;
//         this.v = v;
//     }
//         
//     public Map.Entry<K, V> toEntry() {
//         return new AbstractMap.SimpleEntry<>(k, v);
//     }
// 
//     public K getK() {
//         return k;
//     }
// 
//     public V getV() {
//         return v;
//     }
// 
//     @Override
//     public int hashCode() {
//         int hash = 7;
//         hash = 59 * hash + Objects.hashCode(this.k);
//         hash = 59 * hash + Objects.hashCode(this.v);
//         return hash;
//     }
// 
//     @Override
//     public boolean equals(Object obj) {
//         if (obj == null) {
//             return false;
//         }
//         if (getClass() != obj.getClass()) {
//             return false;
//         }
//         final E<?, ?> other = (E<?, ?>) obj;
//         if (!Objects.equals(this.k, other.k)) {
//             return false;
//         }
//         if (!Objects.equals(this.v, other.v)) {
//             return false;
//         }
//         return true;
//     }
// 
//     @Override
//     public String toString() {
//         return "e(" + k + ", " + v + ')';
//     }
// 
//     @Override
//     public int compareTo(E<K, V> obj) {
//         if (obj == null) {
//             return 1;
//         }
//             
//         if (!(k instanceof Comparable)) {
//             throw new ClassCastException(k.getClass().getName() + " cannot be cast to java.lang.Comparable");
//         }
//         int ret = ((Comparable<K>)k).compareTo(obj.k);
//         if (ret != 0) {
//             return ret;
//         }
//             
//         if (!(v instanceof Comparable)) {
//             throw new ClassCastException(v.getClass().getName() + " cannot be cast to java.lang.Comparable");
//         }
//         ret = ((Comparable<V>)v).compareTo(obj.v);
//             
//         return ret;
//     }
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/U.java
// public static <T> boolean any(Predicate<T> predicate, T... candidates) {
//     return C.toStream(candidates).anyMatch(predicate);
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/abstractions/OmegaObject.java
// public abstract class OmegaObject {
//     /**
//      * Prints itself to the standard output.
//      */
//     public void println() {
//         U.println(this);
//     }
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/abstractions/ReadonlyIndexedI.java
// public interface ReadonlyIndexedI<K, V> extends I<K, V> {
//     
// }
// 
// Path: src/main/java/ch/codebulb/lambdaomega/abstractions/StreamableI.java
// public interface StreamableI {
//     /**
//      * Returns <code>true</code>, if the data structure is parallel streamed.
//      */
//     public boolean isParallel();
// }


// Path: src/main/java/ch/codebulb/lambdaomega/C.java
import ch.codebulb.lambdaomega.M.E;
import static ch.codebulb.lambdaomega.U.any;
import ch.codebulb.lambdaomega.abstractions.OmegaObject;
import ch.codebulb.lambdaomega.abstractions.ReadonlyIndexedI;
import ch.codebulb.lambdaomega.abstractions.StreamableI;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Properties;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.WeakHashMap;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

                return new LinkedHashSet<T>();
            }
            if (format.isAssignableFrom(LinkedList.class)) {
                return new LinkedList<T>();
            }
            if (format.isAssignableFrom(LinkedTransferQueue.class)) {
                return new LinkedTransferQueue<T>();
            }
            if (format.isAssignableFrom(PriorityBlockingQueue.class)) {
                return new PriorityBlockingQueue<T>();
            }
            if (format.isAssignableFrom(PriorityQueue.class)) {
                return new PriorityQueue<T>();
            }
            if (format.isAssignableFrom(Stack.class)) {
                return new Stack<T>();
            }
            // TODO What about SynchronousQueue?
            if (format.isAssignableFrom(TreeSet.class)) {
                return new TreeSet<T>();
            }
            // Vector is considered "obsolete"
            
            throw new IllegalArgumentException("Return type not supported: " + format);
        }));
        }
        
        if (any(it -> format.isAssignableFrom(it), 
                ConcurrentHashMap.class,
                ConcurrentSkipListMap.class)) {
            return (C)collectedStream.stream().collect(Collectors.toConcurrentMap(it -> ((E)it).k, it -> ((E)it).v, (x, y) -> x, () -> {