public static void AppendTextFile(string Path, string Content)
{
      StreamWriter w = null;
      try
      {
        if (!File.Exists(Path))
        {
          w = File.CreateText(Path);
        }
        else
        {
          w = File.AppendText(Path);
        }
        w.Write(Content);
        w.Flush();
      }
      catch (Exception exp)
      {
        throw exp;
      }
      finally
      {
        w.Close();
      }
}

public static int HexToInt(string HexStr)
{
      int Counter, HexInt;
      char[] hexarr;
      HexInt = 0;
      HexStr = HexStr.ToUpper();
      hexarr = HexStr.ToCharArray();
      for (Counter = hexarr.Length - 1; Counter >= 0; Counter--)
      {
        if ((hexarr[Counter] >= '0') && (hexarr[Counter] <= '9'))
        {
          HexInt += (hexarr[Counter] - 48) * ((int)(Math.Pow(16, hexarr.Length - 1 - Counter)));
        }
        else
        {
          if ((hexarr[Counter] >= 'A') && (hexarr[Counter] <= 'F'))
          {
            HexInt += (hexarr[Counter] - 55) * ((int)(Math.Pow(16, hexarr.Length - 1 - Counter)));
          }
          else
          {
            HexInt = 0;
            break;
          }
        }
      }
      return HexInt;
}

public static string IntToHex(int HexInt)
{
      int Counter, Reminder;
      string HexStr;

      Counter = 1;
      HexStr = "";
      while (HexInt + 15 > Math.Pow(16, Counter - 1))
      {
        Reminder = (int)(HexInt % Math.Pow(16, Counter));
        Reminder = (int)(Reminder / Math.Pow(16, Counter - 1));

        if (Reminder <= 9)
        {
          HexStr = HexStr + (char)(Reminder + 48);
        }
        else
        {
          HexStr = HexStr + (char)(Reminder + 55);
        }

        HexInt -= Reminder;
        Counter++;
      }


      return new string(HexStr.Reverse().ToArray());
}

public static string MD5(string StrToEncrypt)
{
      System.Text.UTF8Encoding ue = new System.Text.UTF8Encoding();
      byte[] bytes = ue.GetBytes(StrToEncrypt);

      MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
      byte[] HashBytes = md5.ComputeHash(bytes);

      string HashString = "";

      for (int i = 0; i < HashBytes.Length; i++)
      {
        HashString += Convert.ToString(HashBytes[i], 16).PadLeft(2, '0');
      }

      return HashString.PadLeft(32, '0');
}

public static string RenderHTML(Control control)
{
      StringBuilder sb = new StringBuilder();
      TextWriter tw = new StringWriter(sb);
      HtmlTextWriter htmltw = new HtmlTextWriter(tw);
      control.RenderControl(htmltw);
      return sb.ToString();
}

public static string[] SplitByString(string TestString, string Split)
{
      int offset = 0;
      int index = 0;
      int[] offsets = new int[TestString.Length + 1];

      while (index < TestString.Length)
      {
        int indexOf = TestString.IndexOf(Split, index);
        if (indexOf != -1)
        {
          offsets[offset++] = indexOf;
          index = (indexOf + Split.Length);
        }
        else
        {
          index = TestString.Length;
        }
      }

      string[] final = new string[offset + 1];
      if (offset == 0)
      {
        final[0] = TestString;
      }
      else
      {
        offset--;
        final[0] = TestString.Substring(0, offsets[0]);
        for (int i = 0; i < offset; i++)
        {
          final[i + 1] = TestString.Substring(offsets[i] + Split.Length, offsets[i + 1] - offsets[i] - Split.Length);
        }
        final[offset + 1] = TestString.Substring(offsets[offset] + Split.Length);
      }
      return final;
}

public static string StripHTMLFromString(string htmlText)
{
      return Regex.Replace(htmlText, "<[^>]*>", string.Empty);
}

public static int WordCount(string Text)
{
      string tmpStr;

      tmpStr = Text.Replace("\t", " ").Trim();
      tmpStr = tmpStr.Replace("\n", " ");
      tmpStr = tmpStr.Replace("\r", " ");

      while (tmpStr.IndexOf(" ") != -1)
        tmpStr = tmpStr.Replace(" ", " ");

      return tmpStr.Split(' ').Length;
}

public static string Encrypt(string Message, string Passphrase)
{
    byte[] Results;
    UTF8Encoding UTF8 = new UTF8Encoding();    

    MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
    byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

    TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

    TDESAlgorithm.Key = TDESKey;
    TDESAlgorithm.Mode = CipherMode.ECB;
    TDESAlgorithm.Padding = PaddingMode.PKCS7;

    byte[] DataToEncrypt = UTF8.GetBytes(Message);

    try
    {
      ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
      Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
    }
    finally
    {
      TDESAlgorithm.Clear();
      HashProvider.Clear();
    }

    return Convert.ToBase64String(Results);
}

public static string Decrypt(string Message, string Passphrase)
{
    byte[] Results;
    UTF8Encoding UTF8 = new UTF8Encoding();

    MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
    byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

    TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

    TDESAlgorithm.Key = TDESKey;
    TDESAlgorithm.Mode = CipherMode.ECB;
    TDESAlgorithm.Padding = PaddingMode.PKCS7;

    byte[] DataToDecrypt = Convert.FromBase64String(Message);

    try
    {
      ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
      Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
    }
    finally
    {
      TDESAlgorithm.Clear();
      HashProvider.Clear();
    }

    return UTF8.GetString(Results);
}