context: using System;
  using System.Collections.Generic;
  using System.Diagnostics;
  using System.Globalization;
  using System.IO;
  using System.Linq;
  using System.Net;
  using System.Net.Sockets;
  using System.Reflection;
  using System.Text;
  using System.Text.RegularExpressions;
  using System.Threading;
  using System.Threading.Tasks;
  using Windows.Networking;
  using Windows.Networking.Sockets;
  
  namespace WinrtCifs.Util.Sharpen
  {
  
  
      public static class Extensions
      {
          private static readonly long EpochTicks;
  
          static Extensions()
          {
              DateTime time = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
              EpochTicks = time.Ticks;
          }
  
  
          public static string Decode(this Encoding e, byte[] chars, int start, int len)
          {
              try
              {
                  byte[] bom = e.GetPreamble();
                  if (bom != null && bom.Length > 0)
                  {
                      if (len >= bom.Length)
                      {
                          int pos = start;
                          bool hasBom = true;
                          for (int n = 0; n < bom.Length && hasBom; n++)
                          {
                              if (bom[n] != chars[pos++])
                                  hasBom = false;
                          }
                          if (hasBom)
                          {
                              len -= pos - start;
                              start = pos;
                          }
                      }
                  }
                  return e.GetString(chars, start, len);
              }
              catch (DecoderFallbackException)
              {
                  throw new CharacterCodingException();
              }
          }
  
  
  
  
  
    
  
  
          public static TU Put<T, TU>(this IDictionary<T, TU> d, T key, TU value)
          {
              TU old;
              d.TryGetValue(key, out old);
              d[key] = value;
              return old;
          }
  
  
  
        
  
          public static long GetTime(this DateTime dateTime)
          {
              return new DateTimeOffset(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc), TimeSpan.Zero).ToMillisecondsSinceEpoch();
          }
  
          public static void InitCause(this Exception ex, Exception cause)
          {
              LogStream.GetInstance().WriteLine(cause);
          }
  
     
  
     
  
  
          public static DateTime CreateDate(long milliSecondsSinceEpoch)
          {
              long num = EpochTicks + (milliSecondsSinceEpoch * 10000);
              return new DateTime(num);
          }
  
          public static DateTime CreateDateFromUTC(long milliSecondsSinceEpoch)
          {
              long num = EpochTicks + (milliSecondsSinceEpoch * 10000);
              return new DateTime(num, DateTimeKind.Utc);
          }
  
  
          public static DateTimeOffset MillisToDateTimeOffset(long milliSecondsSinceEpoch, long offsetMinutes)
          {
              TimeSpan offset = TimeSpan.FromMinutes(offsetMinutes);
              long num = EpochTicks + (milliSecondsSinceEpoch * 10000);
              return new DateTimeOffset(num + offset.Ticks, offset);
          }
  
          public static int NumberOfLeadingZeros(int val)
          {
              uint num = (uint)val;
              int count = 0;
              while ((num & 0x80000000) == 0)
              {
                  num = num << 1;
                  count++;
              }
              return count;
          }
  
          public static int NumberOfTrailingZeros(int val)
          {
              uint num = (uint)val;
              int count = 0;
              while ((num & 1) == 0)
              {
                  num = num >> 1;
                  count++;
              }
              return count;
          }
  
          public static int Read(this StreamReader reader, char[] data)
          {
              return reader.Read(data, 0, data.Length);
          }
  
          public static T Remove<T>(this IList<T> list, T item)
          {
              int index = list.IndexOf(item);
              if (index == -1)
              {
                  return default(T);
              }
              T local = list[index];
              list.RemoveAt(index);
              return local;
          }
  
          public static T Remove<T>(this IList<T> list, int i)
          {
              T old;
              try
              {
                  old = list[i];
                  list.RemoveAt(i);
              }
              catch (IndexOutOfRangeException)
              {
                  throw new NoSuchElementException();
              }
              return old;
          }
  
          public static T RemoveFirst<T>(this IList<T> list)
          {
              return list.Remove(0);
          }
  
          public static string ReplaceAll(this string str, string regex, string replacement)
          {
              Regex rgx = new Regex(regex);
  
              if (replacement.IndexOfAny(new[] { '\\', '$' }) != -1)
              {
                  // Back references not yet supported
                  StringBuilder sb = new StringBuilder();
                  for (int n = 0; n < replacement.Length; n++)
                  {
                      char c = replacement[n];
                      if (c == '$')
                          throw new NotSupportedException("Back references not supported");
                      if (c == '\\')
                          c = replacement[++n];
                      sb.Append(c);
                  }
                  replacement = sb.ToString();
              }
  
              return rgx.Replace(str, replacement);
          }
  
          public static bool RegionMatches(this string str, bool ignoreCase, int toOffset, string other, int ooffset, int len)
          {
              if (toOffset < 0 || ooffset < 0 || toOffset + len > str.Length || ooffset + len > other.Length)
                  return false;
              return string.Compare(str, toOffset, other, ooffset, len) == 0;
          }
  
          public static T Set<T>(this IList<T> list, int index, T item)
          {
              T old = list[index];
              list[index] = item;
              return old;
          }
  
          public static int Signum(long val)
          {
              if (val < 0)
              {
                  return -1;
              }
              if (val > 0)
              {
                  return 1;
              }
              return 0;
          }
  
          public static void RemoveAll<T, TU>(this ICollection<T> col, ICollection<TU> items) where TU : T
          {
              foreach (var u in items)
                  col.Remove(u);
          }
  
          public static bool ContainsAll<T, TU>(this ICollection<T> col, ICollection<TU> items) where TU : T
          {
              foreach (var u in items)
                  if (!col.Any(n => (ReferenceEquals(n, u)) || n.Equals(u)))
                      return false;
              return true;
          }
  
          public static bool Contains<T>(this ICollection<T> col, object item)
          {
              if (!(item is T))
                  return false;
              return col.Any(n => (ReferenceEquals(n, item)) || n.Equals(item));
          }
  
          public static void Sort<T>(this IList<T> list)
          {
              List<T> sorted = new List<T>(list);
              sorted.Sort();
              for (int i = 0; i < list.Count; i++)
              {
                  list[i] = sorted[i];
              }
          }
  
          public static void Sort<T>(this IList<T> list, IComparer<T> comparer)
          {
              List<T> sorted = new List<T>(list);
              sorted.Sort(comparer);
              for (int i = 0; i < list.Count; i++)
              {
                  list[i] = sorted[i];
              }
          }
  
          public static string[] Split(this string str, string regex)
          {
              return str.Split(regex, 0);
          }
  
          public static string[] Split(this string str, string regex, int limit)
          {
              Regex rgx = new Regex(regex);
              List<string> list = new List<string>();
              int startIndex = 0;
              if (limit != 1)
              {
                  int nm = 1;
                  foreach (Match match in rgx.Matches(str))
                  {
                      list.Add(str.Substring(startIndex, match.Index - startIndex));
                      startIndex = match.Index + match.Length;
                      if (limit > 0 && ++nm == limit)
                          break;
                  }
              }
              if (startIndex < str.Length)
              {
                  list.Add(str.Substring(startIndex));
              }
              if (limit >= 0)
              {
                  int count = list.Count - 1;
                  while ((count >= 0) && (list[count].Length == 0))
                  {
                      count--;
                  }
                  list.RemoveRange(count + 1, (list.Count - count) - 1);
              }
              return list.ToArray();
          }
  
          public static IList<T> SubList<T>(this IList<T> list, int start, int len)
          {
              List<T> sublist = new List<T>(len);
              for (int i = start; i < (start + len); i++)
              {
                  sublist.Add(list[i]);
              }
              return sublist;
          }
  
          public static char[] ToCharArray(this string str)
          {
              char[] destination = new char[str.Length];
              str.CopyTo(0, destination, 0, str.Length);
              return destination;
          }
  
          public static long ToMillisecondsSinceEpoch(this DateTime dateTime)
          {
              if (dateTime.Kind != DateTimeKind.Utc)
              {
                  throw new ArgumentException("dateTime is expected to be expressed as a UTC DateTime", "dateTime");
              }
              return new DateTimeOffset(DateTime.SpecifyKind(dateTime, DateTimeKind.Utc), TimeSpan.Zero).ToMillisecondsSinceEpoch();
          }
  
          public static long ToMillisecondsSinceEpoch(this DateTimeOffset dateTimeOffset)
          {
              return (((dateTimeOffset.Ticks - dateTimeOffset.Offset.Ticks) - EpochTicks) / TimeSpan.TicksPerMillisecond);
          }
  
          public static string ToOctalString(int val)
          {
              return Convert.ToString(val, 8);
          }
  
          public static string ToHexString(int val)
          {
              return Convert.ToString(val, 16);
          }
  
          public static string ToString(object val)
          {
              return val.ToString();
          }
  
          public static string ToString(int val, int bas)
          {
              return Convert.ToString(val, bas);
          }
  
          public static IList<TU> UpcastTo<T, TU>(this IList<T> s) where T : TU
          {
              List<TU> list = new List<TU>(s.Count);
              for (int i = 0; i < s.Count; i++)
              {
                  list.Add(s[i]);
              }
              return list;
          }
  
          public static ICollection<TU> UpcastTo<T, TU>(this ICollection<T> s) where T : TU
          {
              List<TU> list = new List<TU>(s.Count);
              foreach (var v in s)
              {
                  list.Add(v);
              }
              return list;
          }
  
          public static T ValueOf<T>(T val)
          {
              return val;
          }
        
          
          public static string GetHostAddress(this IPAddress addr)
          {
              return addr.ToString();
          }
  
  
          public static IPAddress GetAddressByName(string host)
          {
              if (host == "0.0.0.0")
              {
                  return IPAddress.Any;
              }                
              
              try
              {
                  return IPAddress.Parse(host);
              }
              catch (Exception)
              {
                  return null;
              }            
          }
  
          public static IPAddress[] GetAddressesByName(string host)
          {
              IReadOnlyList<EndpointPair> data = null;
  
              try
              {
                  Task.Run(async () =>
                  {
                      data = await DatagramSocket.GetEndpointPairsAsync(new HostName(host), "0");
                  }).Wait();
              }
              catch (Exception )
              {
                  return null;
              }
  
              return data != null
                  ? data.Where(i => i.RemoteHostName.Type == HostNameType.Ipv4).GroupBy(i => i.RemoteHostName.DisplayName)
                      .Select(i => IPAddress.Parse(i.First().RemoteHostName.DisplayName))
                      .ToArray() : null; 
          }
  
          public static string GetImplementationVersion(this Assembly asm)
          {
              return asm.GetName().Version.ToString();
          }
  
          public static string GetHost(this Uri uri)
          {
              return string.IsNullOrEmpty(uri.Host) ? "" : uri.Host;
          }
  
          public static string GetUserInfo(this Uri uri)
          {
  
gt:             return string.IsNullOrEmpty(uri.UserInfo) ? null : uri.UserInfo;