try(final ByteArrayInputStream bis = new ByteArrayInputStream(data);

public static DecryptedHashlink DecodeHashlink(String hashlink)
        {
            DecryptedHashlink room = new DecryptedHashlink();

            try
            {
                if (hashlink.ToUpper().StartsWith("CHATROOM:")) // not encrypted
                {
                    hashlink = hashlink.Substring(9);
                    int split = hashlink.IndexOf(":");
                    room.IP = IPAddress.Parse(hashlink.Substring(0, split));
                    hashlink = hashlink.Substring(split + 1);
                    split = hashlink.IndexOf("|");
                    room.Port = ushort.Parse(hashlink.Substring(0, split));
                    room.Name = hashlink.Substring(split + 1);
                    return room;
                }
                else // encrypted
                {
                    byte[] buf = Convert.FromBase64String(hashlink);
                    buf = d67(buf, 28435); //hasta ahí pude traducir sin problemas
                    buf = Zip.Decompress(buf);

                    HashlinkReader reader = new HashlinkReader(buf);
                    reader.SkipBytes(32);
                    room.IP = reader;
                    room.Port = reader;
                    reader.SkipBytes(4);
                    room.Name = reader;

                    return room;
                }
            }
            catch // badly formed hashlink
            {
                return null;
            }
        }

public class InflaterInputStream {
	public InflaterInputStream(Stream baseInputStream)
	{
		this(baseInputStream, new Inflater(), 4096);
	}

	/// <summary>
	/// Create an InflaterInputStream with the specified decompressor
	/// and a default buffer size of 4KB.
	/// </summary>
	/// <param name = "baseInputStream">
	/// The source of input data
	/// </param>
	/// <param name = "inf">
	/// The decompressor used to decompress data read from baseInputStream
	/// </param>
	

	/// <summary>
	/// Create an InflaterInputStream with the specified decompressor
	/// and the specified buffer size.
	/// </summary>
	/// <param name = "baseInputStream">
	/// The InputStream to read bytes from
	/// </param>
	/// <param name = "inflater">
	/// The decompressor to use
	/// </param>
	/// <param name = "bufferSize">
	/// Size of the buffer to use
	/// </param>
	public InflaterInputStream(Stream baseInputStream, Inflater inflater, int bufferSize)
	{
		if (baseInputStream == null)
		{
			throw new ArgumentNullException(nameof(baseInputStream));
		}

		if (inflater == null)
		{
			throw new ArgumentNullException(nameof(inflater));
		}

		if (bufferSize <= 0)
		{
			throw new ArgumentOutOfRangeException(nameof(bufferSize));
		}

		this.baseInputStream = baseInputStream;
		this.inf = inflater;

		inputBuffer = new InflaterInputBuffer(baseInputStream, bufferSize);
	}
}

public static byte[] Decompress(byte[] data)
        {
            try
            {
                byte[] r = null;

                using (MemoryStream ms = new MemoryStream(data))
                using (Stream s = new InflaterInputStream(ms))
                {
                    List<byte> list = new List<byte>();
                    int count = 0;
                    byte[] b = new byte[8192];

                    while ((count = s.Read(b, 0, 8192)) > 0)
                        list.AddRange(b.Take(count));

                    r = list.ToArray();
                    list.Clear();
                    list = null;
                }

                return r;
            }
            catch { }

            return new byte[] { };
        }

using (MemoryStream ms = new MemoryStream(data))
using (Stream s = new InflaterInputStream(ms))