context: #if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
  using System;
  using System.Text;
  
  using Org.BouncyCastle.Utilities;
  
  namespace Org.BouncyCastle.Asn1
  {
  	public class DerBitString
  		: DerStringBase
  	{
  		private static readonly char[] table
  			= { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  
  		private readonly byte[]	data;
  		private readonly int	padBits;
  
  		/**
  		 * return the correct number of pad bits for a bit string defined in
  		 * a 32 bit constant
  		 */
  		static internal int GetPadBits(
  			int bitString)
  		{
  			int val = 0;
  			for (int i = 3; i >= 0; i--)
  			{
  				//
  				// this may look a little odd, but if it isn't done like this pre jdk1.2
  				// JVM's break!
  				//
  				if (i != 0)
  				{
  					if ((bitString >> (i * 8)) != 0)
  					{
  						val = (bitString >> (i * 8)) & 0xFF;
  						break;
  					}
  				}
  				else
  				{
  					if (bitString != 0)
  					{
  						val = bitString & 0xFF;
  						break;
  					}
  				}
  			}
  
  			if (val == 0)
  			{
  				return 7;
  			}
  
  			int bits = 1;
  
  			while (((val <<= 1) & 0xFF) != 0)
  			{
  				bits++;
  			}
  
  			return 8 - bits;
  		}
  
  		/**
  		 * return the correct number of bytes for a bit string defined in
  		 * a 32 bit constant
  		 */
  		static internal byte[] GetBytes(
  			int bitString)
  		{
  			int bytes = 4;
  			for (int i = 3; i >= 1; i--)
  			{
  				if ((bitString & (0xFF << (i * 8))) != 0)
  				{
  					break;
  				}
  				bytes--;
  			}
  
  			byte[] result = new byte[bytes];
  			for (int i = 0; i < bytes; i++)
  			{
  				result[i] = (byte) ((bitString >> (i * 8)) & 0xFF);
  			}
  
  			return result;
  		}
  
  		/**
  		 * return a Bit string from the passed in object
  		 *
  		 * @exception ArgumentException if the object cannot be converted.
  		 */
  		public static DerBitString GetInstance(
  			object obj)
  		{
  			if (obj == null || obj is DerBitString)
  			{
  				return (DerBitString) obj;
  			}
  
  			throw new ArgumentException("illegal object in GetInstance: " + obj.GetType().Name);
  		}
  
  		/**
  		 * return a Bit string from a tagged object.
  		 *
  		 * @param obj the tagged object holding the object we want
  		 * @param explicitly true if the object is meant to be explicitly
  		 *              tagged false otherwise.
  		 * @exception ArgumentException if the tagged object cannot
  		 *               be converted.
  		 */
  		public static DerBitString GetInstance(
  			Asn1TaggedObject	obj,
  			bool				isExplicit)
  		{
  			Asn1Object o = obj.GetObject();
  
  			if (isExplicit || o is DerBitString)
  			{
  				return GetInstance(o);
  			}
  
  			return FromAsn1Octets(((Asn1OctetString)o).GetOctets());
  		}
  
  		internal DerBitString(
  			byte	data,
  			int		padBits)
  		{
  			this.data = new byte[]{ data };
  			this.padBits = padBits;
  		}
  
  		/**
  		 * @param data the octets making up the bit string.
  		 * @param padBits the number of extra bits at the end of the string.
  		 */
  		public DerBitString(
  			byte[]	data,
  			int		padBits)
  		{
  			// TODO Deep copy?
  			this.data = data;
  			this.padBits = padBits;
  		}
  
  		public DerBitString(
  			byte[] data)
  		{
  			// TODO Deep copy?
  			this.data = data;
  		}
  
  		public DerBitString(
  			Asn1Encodable obj)
  		{
  			this.data = obj.GetDerEncoded();
  			//this.padBits = 0;
  		}
  
  		public byte[] GetBytes()
  		{
  			return data;
  		}
  
  		public int PadBits
  		{
  			get { return padBits; }
  		}
  
  		/**
  		 * @return the value of the bit string as an int (truncating if necessary)
  		 */
  		public int IntValue
  		{
  			get
  			{
  				int value = 0;
  
  				for (int i = 0; i != data.Length && i != 4; i++)
  				{
  					value |= (data[i] & 0xff) << (8 * i);
  				}
  
  				return value;
  			}
  		}
  
  		internal override void Encode(
  			DerOutputStream derOut)
  		{
  			byte[] bytes = new byte[GetBytes().Length + 1];
  
  			bytes[0] = (byte) PadBits;
  			Array.Copy(GetBytes(), 0, bytes, 1, bytes.Length - 1);
  
  			derOut.WriteEncoded(Asn1Tags.BitString, bytes);
  		}
  
  		protected override int Asn1GetHashCode()
  		{
  			return padBits.GetHashCode() ^ Arrays.GetHashCode(data);
  		}
  
  		protected override bool Asn1Equals(
  			Asn1Object asn1Object)
  		{
  			DerBitString other = asn1Object as DerBitString;
  
  			if (other == null)
  				return false;
  
  			return this.padBits == other.padBits
  				&& Arrays.AreEqual(this.data, other.data);
  		}
  
  		public override string GetString()
  		{
  			StringBuilder buffer = new StringBuilder("#");
  
  			byte[] str = GetDerEncoded();
  
  			for (int i = 0; i != str.Length; i++)
  			{
  				uint ubyte = str[i];
  				buffer.Append(table[(ubyte >> 4) & 0xf]);
  				buffer.Append(table[str[i] & 0xf]);
  			}
  
  			return buffer.ToString();
  		}
  
  		internal static DerBitString FromAsn1Octets(byte[] octets)
  		{
  	        if (octets.Length < 1)
  	            throw new ArgumentException("truncated BIT STRING detected");
  
  			int padBits = octets[0];
  			byte[] data = new byte[octets.Length - 1];
  
gt: 			Array.Copy(octets, 1, data, 0, data.Length);