using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Diagnostics;

public class Program{

    private static void Bench(Action method,int passes=1000){

        GC.Collect();

        method();

        var stopwatch = Stopwatch.StartNew();

        for(var index=0;index<passes;++index){method();}

        Console.WriteLine(stopwatch.Elapsed.TotalMilliseconds + " ms");

    }

    public static void Main(string[] args){

        var a = new Dictionary<string,int>();

        a["0"] = 0;

        a["1"] = 1;

        a["2"] = 2;

        a["3"] = 3;

        var b = new Dictionary<string,int>();

        a["a"] = 0;

        a["b"] = 1;

        a["c"] = 2;

        a["d"] = 3;

        var x = new List<int>();

        x.Add(1);

        x.Add(2);

        x.TryGet(0,out var whatever);

        Bench(()=>{

        });

        Bench(()=>{

        });

    }

}

    public static class IEnumerableExtensions{

        //=======================================

        // Has(X)

        //=======================================

        public static bool Has<X>(this IEnumerable<X> current,X value) => current.Any(x=>x.Equals(value));

        public static bool Exists<X>(this IEnumerable<X> current,X value) => current.Has(value);

        public static bool Contains<X>(this IEnumerable<X> current,X value) => current.Has(value);

        public static bool Any<X>(this IEnumerable<X> current,X value) => current.Has(value);

        //=======================================

        // HasAny(params X[])

        //=======================================

        public static bool HasAny<X>(this IEnumerable<X> current,params X[] values) => current.Any(x=>values.Contains(x));

        public static bool ExistsAny<X>(this IEnumerable<X> current,params X[] values) => current.HasAny(values);

        public static bool ContainsAny<X>(this IEnumerable<X> current,params X[] values) => current.HasAny(values);

        public static bool Any<X>(this IEnumerable<X> current,params X[] values) => current.HasAny(values);

        //=======================================

        // HasAny(params IEnumerable<X>[])

        //=======================================

        public static bool HasAny<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => others.Any(x=>x.Any(y=>current.Contains(y)));

        public static bool ExistsAny<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => current.HasAny(others);

        public static bool ContainsAny<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => current.HasAny(others);

        public static bool Any<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => current.HasAny(others);

        //=======================================

        // HasAny(Predicate<X>)

        //=======================================

        public static bool HasAny<X>(this IEnumerable<X> current,Predicate<X> method){

            foreach(var item in current){

                if(method(item)){return true;}

            }

            return false;

        }

        public static bool Exists<X>(this IEnumerable<X> current,Predicate<X> method) => current.HasAny(method);

        public static bool Contains<X>(this IEnumerable<X> current,Predicate<X> method) => current.HasAny(method);

        public static bool Any<X>(this IEnumerable<X> current,Predicate<X> method) => current.HasAny(method);

        //=======================================

        // HasAll(params X[])

        //=======================================

        public static bool HasAll<X>(this IEnumerable<X> current,params X[] values){

            for(var index=0;index<values.Length;++index){

                if(!current.Contains(values[index])){return false;}

            }

            return true;

        }

        public static bool ExistsAll<X>(this IEnumerable<X> current,params X[] values) => current.HasAll(values);

        public static bool ContainsAll<X>(this IEnumerable<X> current,params X[] values) => current.HasAll(values);

        public static bool All<X>(this IEnumerable<X> current,params X[] values) => current.HasAll(values);

        //=======================================

        // HasAll(params IEnumerable<X>[])

        //=======================================

        public static bool HasAll<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => others.All(x=>x.All(y=>current.Contains(y)));

        public static bool ExustsAll<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => current.HasAll(others);

        public static bool ContainsAll<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => current.HasAll(others);

        public static bool All<X>(this IEnumerable<X> current,params IEnumerable<X>[] others) => current.HasAll(others);

        //=======================================

        // HasAll(Predicate<X>)

        //=======================================

        public static bool HasAll<X>(this IEnumerable<X> current,Predicate<X> method){

            var output = true;

            current.ForEach(x=>output = output && method(x));

            return output;

        }

        public static bool ContainsAll<X>(this IEnumerable<X> current,Predicate<X> method) => current.HasAny(method);

        public static bool ExistsAll<X>(this IEnumerable<X> current,Predicate<X> method) => current.HasAny(method);

        public static bool All<X>(this IEnumerable<X> current,Predicate<X> method) => current.HasAny(method);

        //=======================================

        // TryFind(int)

        //=======================================

        public static bool TryGetIndex<X>(this IEnumerable<X> current,X value,out int index){

            index = current.GetIndex(value);

            return index != -1;

        }

        public static IEnumerable<bool> TryGetKeys<X>(this IEnumerable<X> current,out int[] indices,params X[] values){

            indices = current.GetKeys(values).ToArray();

            return values.Select(x=>current.Has(x));

        }

        public static bool TryGetKey<X>(this IEnumerable<X> current,X value,out int index) => current.TryGetIndex(value,out index);

        public static bool TryGet<X>(this IEnumerable<X> current,int index,out X value){

            value = default;

            var indexes = current.Indexes();

            if(indexes.Has(index)){

                value = current.Get(index);

                return true;

            }

            return false;

        }

        public static IEnumerable<bool> TryGet<X>(this IEnumerable<X> current,out X[] values,params int[] indices){

            var output = new List<bool>();

            var outputValues = new List<X>();

            foreach(var index in indices){

                output.Add(current.TryGet(index,out var value));

                outputValues.Add(value);

            }

            values = outputValues.ToArray();

            return output;

        }

        //=======================================

        // Get(params index[])

        //=======================================

        public static X Get<X>(this IEnumerable<X> current,int index){

            Console.WriteLine("Enum");

            var currentIndex = 0;

            foreach(var item in current){

                if(index == currentIndex){return item;}

                ++currentIndex;

            }

            return default;

        }

        public static IEnumerable<X> Get<X>(this IEnumerable<X> current,params int[] indices) => current.WhereByIndex(x=>indices.Contains(x));

        public static IEnumerable<X> GetAll<X>(this IEnumerable<X> current,params int[] indices) => current.Get(indices);

        //=======================================

        // Get(Predicate<X>)

        //=======================================

        public static X Get<X>(this IEnumerable<X> current,Predicate<X> method) => current.FirstOrDefault(x=>method(x));

        public static X Find<X>(this IEnumerable<X> current,Predicate<X> method) => current.Get(method);

        public static IEnumerable<X> GetAll<X>(this IEnumerable<X> current,Predicate<X> method) => current.Where(x=>method(x));

        public static IEnumerable<X> FindAll<X>(this IEnumerable<X> current,Predicate<X> method) => current.GetAll(method);

        //=======================================

        // GetKey(X)

        //=======================================

        public static int GetKey<X>(this IEnumerable<X> current,X value) => current.IndexOf((x)=>x.Equals(value));

        public static int KeyOf<X>(this IEnumerable<X> current,X value) => current.GetKey(value);

        public static int FindKey<X>(this IEnumerable<X> current,X value) => current.GetKey(value);

        public static int Key<X>(this IEnumerable<X> current,X value) => current.GetKey(value);

        public static int GetIndex<X>(this IEnumerable<X> current,X value) => current.GetKey(value);

        public static int IndexOf<X>(this IEnumerable<X> current,X value) => current.GetKey(value);

        public static int FindIndex<X>(this IEnumerable<X> current,X value) => current.GetKey(value);

        public static int Index<X>(this IEnumerable<X> current,X value) => current.GetKey(value);

        //=======================================

        // GetKey(Predicate<X>)

        //=======================================

        public static int GetKey<X>(this IEnumerable<X> current,Func<X,bool> method){

            var index = 0;

            foreach(var value in current){

                if(method(value)){return index;}

                index++;

            }

            return -1;

        }

        public static int KeyOf<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKey(method);

        public static int FindKey<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKey(method);

        public static int Key<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKey(method);

        public static int GetIndex<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKey(method);

        public static int IndexOf<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKey(method);

        public static int FindIndex<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKey(method);

        public static int Index<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKey(method);

        //=======================================

        // GetKeys/GetIndexes

        //=======================================

        public static IEnumerable<int> GetKeys<X>(this IEnumerable<X> current) => Enumerable.Range(0,current.Count()+1);

        public static IEnumerable<int> GetKeys<X>(this IEnumerable<X> current,Func<X,bool> method){

            var index = 0;

            foreach(var item in current){

                if(method(item)){yield return index++;}

            }

        }

        public static IEnumerable<int> GetKeys<X>(this IEnumerable<X> current,params X[] values) => current.GetKeys(x=>values.Contains(x));

        public static IEnumerable<int> Keys<X>(this IEnumerable<X> current,params X[] values) => current.GetKeys(values);

        public static IEnumerable<int> Keys<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKeys(method);

        public static IEnumerable<int> Keys<X>(this IEnumerable<X> current) => current.GetKeys();

        public static IEnumerable<int> GetIndexes<X>(this IEnumerable<X> current) => current.GetKeys();

        public static IEnumerable<int> GetIndexes<X>(this IEnumerable<X> current,params X[] values) => current.GetKeys(x=>values.Contains(x));

        public static IEnumerable<int> GetIndexes<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKeys(method);

        public static IEnumerable<int> Indexes<X>(this IEnumerable<X> current) => current.GetKeys();

        public static IEnumerable<int> Indexes<X>(this IEnumerable<X> current,params X[] values) => current.GetKeys(values);

        public static IEnumerable<int> Indexes<X>(this IEnumerable<X> current,Func<X,bool> method) => current.GetKeys(method);

        //=======================================

        // First/Last/Skip/Take

        //=======================================

        public static X? FirstOrNull<X>(this IEnumerable<X> current){

            foreach(var item in current){return item;}

            return default;

        }

        public static X? LastOrNull<X>(this IEnumerable<X> current){

            var result = default(X?);

            foreach(var item in current){result = item;}

            return result;

        }

        public static IEnumerable<X> SkipRight<X>(this IEnumerable<X> current,int amount) => current.SkipLast(amount);

        public static IEnumerable<X> SkipLast<X>(this IEnumerable<X> current) => current.SkipLast(1);

        public static IEnumerable<X> TakeRight<X>(this IEnumerable<X> current,int amount) => current.TakeLast(amount);

        public static IEnumerable<X> TakeLast<X>(this IEnumerable<X> current) => current.TakeLast(1);

        //=======================================

        // WhereByKey/SelectByKey

        //=======================================

        public static IEnumerable<X> WhereByKey<X>(this IEnumerable<X> current,Func<int,bool> executor){

            var index = 0;

            foreach(var item in current){

                if(executor(index)){yield return item;}

                index++;

            }

        }

        public static IEnumerable<OutputType> SelectByKey<X,OutputType>(this IEnumerable<X> current,Func<int,OutputType> executor){

            for(var index=0;index<current.Count();++index){

                yield return executor(index);

            }

        }

        public static IEnumerable<X> WhereByIndex<X>(this IEnumerable<X> current,Func<int,bool> executor) => current.WhereByKey(executor);

        public static IEnumerable<OutputType> SelectByIndex<X,OutputType>(this IEnumerable<X> current,Func<int,OutputType> executor) => current.SelectByKey(executor);

        //=======================================

        // Count(params X[])

        //=======================================

        public static IEnumerable<int> CountEach<X>(this IEnumerable<X> current,params X[] values){

            foreach(var value in values){

                yield return current.Count(x=>values.Contains(x));

            }

        }

        public static int SameCount<X>(this IEnumerable<X> current,params X[] values) => current.Same(values).Count();

        public static int DifferentCount<X>(this IEnumerable<X> current,params X[] values) => current.Different(values).Count();

        public static int UniqueCount<X>(this IEnumerable<X> current,params X[] values) => current.Unique(values).Count();

        //=======================================

        // Count(params IEnumerable<X>[])

        //=======================================

        public static int CountAll<X>(this IEnumerable<X> current,params IEnumerable<X>[] values){

            var count = 0;

            foreach(var items in values){

                foreach(var item in items){

                    if(current.Contains(item)){

                        count++;

                    }

                }

            }

            return count;

        }

        public static int SameCount<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => current.Same(values).Count();

        public static int DifferentCount<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => current.Different(values).Count();

        public static int UniqueCount<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => current.Unique(values).Count();

        //=======================================

        // Count(Predicate<X>)

        //=======================================

        public static int Count<X>(this IEnumerable<X> current,Predicate<X> method){

            var count = 0;

            foreach(var item in current){

                if(method(item)){++count;}

            }

            return count;

        }

        //=======================================

        // Compare(params X[])

        //=======================================

        public static IEnumerable<X> Same<X>(this IEnumerable<X> current,params X[] values) => current.Intersect(values);

        public static IEnumerable<X> Different<X>(this IEnumerable<X> current,params X[] values) => current.Except(values);

        public static IEnumerable<X> Unique<X>(this IEnumerable<X> current,params X[] other){

            return current.Except(other).Concat(other.Except(current));

        }

        //=======================================

        // Compare(params IEnumerable<X>[])

        //=======================================

        public static IEnumerable<X> Filter<X>(this IEnumerable<X> current,Func<IEnumerable<X>,IEnumerable<X>,IEnumerable<X>> method,params IEnumerable<X>[] values){

            foreach(var collection in values){current = method(current,collection);}

            return current;

        }

        public static IEnumerable<X> Same<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => current.Filter((x,y)=>x.Intersect(y),values);

        public static IEnumerable<X> Different<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => current.Filter((x,y)=>x.Except(y),values);

        public static IEnumerable<X> Unique<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => current.Filter((x,y)=>x.Except(y).Concat(y.Except(x)),values);

        public static IEnumerable<X> Different<X>(this IEnumerable<X> current,IEnumerable<X> other) => other.Except(current);

        //=======================================

        // Matches(params X[])

        //=======================================

        public static bool Matches<X>(this IEnumerable<X> current,params X[] values) => Enumerable.SequenceEqual(current,values);

        public static bool SequenceEqual<X>(this IEnumerable<X> current,params X[] values) => current.Matches(values);

        public static bool Mismatches<X>(this IEnumerable<X> current,params X[] values) => !current.Matches(values);

        public static bool SequenceUnequal<X>(this IEnumerable<X> current,params X[] values) => !current.Matches(values);

        //=======================================

        // Matches(params IEnumerable<X>[])

        //=======================================

        public static bool Matches<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => !values.Any(x=>!Enumerable.SequenceEqual(current,x));

        public static bool Mismatches<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => !current.Matches(values);

        public static bool SequenceUnequal<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => !current.Matches(values);

        public static bool SequenceEqual<X>(this IEnumerable<X> current,params IEnumerable<X>[] values) => current.Matches(values);

        //=======================================

        // For/ForEach

        //=======================================

        public static IEnumerable<X> For<X>(this IEnumerable<X> current,Action<int> executor){

            for(var index=0;index<current.Count();++index){executor(index);}

            return current;

        }

        public static IEnumerable<X> ForEach<X>(this IEnumerable<X> current,Action<X> executor){

            foreach(var item in current){executor(item);}

            return current;

        }

        public static IEnumerable<X> ForEach<X,Y>(this IEnumerable<X> current,Func<X,Y> executor){

            foreach(var item in current){executor(item);}

            return current;

        }

        //=======================================

        // General

        //=======================================

    }

public static class IListExtension{

        //=======================================

        // TryFind(int)

        //=======================================

        public static bool TryGetIndex<X>(this IList<X> current,X value,out int index){

            index = current.GetIndex(value);

            return index != -1;

        }

        public static IEnumerable<bool> TryGetKeys<X>(this IList<X> current,out int[] indices,params X[] values){

            indices = current.GetKeys(values).ToArray();

            return values.Select(x=>current.Has(x));

        }

        public static bool TryGetKey<X>(this IList<X> current,X value,out int index) => current.TryGetIndex(value,out index);

        public static IEnumerable<bool> TryGet<X>(this IList<X> current,out X[] values,params int[] indices){

            var output = new List<bool>();

            var outputValues = new List<X>();

            foreach(var index in indices){

                output.Add(current.TryGet(index,out var value));

                outputValues.Add(value);

            }

            values = outputValues.ToArray();

            return output;

        }

        //=======================================

        // Get(params index[])

        //=======================================

        public static X Get<X>(this IList<X> current,int index){

            Console.WriteLine("IListz");

            return current[index];

        }

        public static IList<X> Get<X>(this IList<X> current,params int[] indices){

            var result = new List<X>(indices.Length);

            indices.For(x=>result.Add(current[indices[x]]));

            return result;

        }

        public static IList<X> GetAll<X>(this IList<X> current,params int[] indices) => current.Get(indices);

        //=======================================

        // For/ForEach

        //=======================================

        public static IList<X> For<X>(this IList<X> current,Action<int> executor){

            for(var index=0;index<current.Count;++index){executor(index);}

            return current;

        }

        public static IList<X> ForEach<X>(this IList<X> current,Action<X> executor){

            for(var index=0;index<current.Count;++index){executor(current[index]);}

            return current;

        }

        public static IList<X> ForEach<X,Y>(this IList<X> current,Func<X,Y> executor){

            for(var index=0;index<current.Count;++index){executor(current[index]);}

            return current;

        }

    }