System.IO.MemoryStream.WriteByte(byte)

public int Write(string str, bool duplicates = false, bool stripCr = true)
        {
            if (stripCr)
                str = str.Replace("\r\n", "\n").Replace(Environment.NewLine, "\n");

            var offset = 0;
            if (str == "") //Empty string always 0
                return offset;

            //WDB2 with MaxId allows duplicates else distinct strings
            if (duplicates || !stringlookup.TryGetValue(str, out offset))
            {
                byte[] strBytes = Encoding.UTF8.GetBytes(str);
                offset = (int) StringStream.Position;

                if (!duplicates)
                    stringlookup.Add(str, offset);

                StringStream.Write(strBytes, 0, strBytes.Length);
                StringStream.WriteByte(0);
            }

            return offset;
        }

private static void replacedertRepeatedBetweenLongUncompressable(
            int leftUncompressedSize,
            int repeatedByteSize,
            int rightUncompressedSize)
        {
            var uncompressedData = CreateRepeatedBetweenUncompressable(
                leftUncompressedSize,
                repeatedByteSize,
                rightUncompressedSize);

            var compressedSize = 2
                + leftUncompressedSize
                + repeatedByteSize
                + rightUncompressedSize
                + 1;

            var expectedCompressedData = new byte[compressedSize];
            using (var stream = new MemoryStream(expectedCompressedData))
            {
                var writeSize = uncompressedData.Length - 1;
                stream.WriteByte(
                    (byte)(0xE0 | (writeSize >> 8)));

                stream.WriteByte(
                    (byte)writeSize);

                stream.Write(
                    Uncompressable,
                    0,
                    leftUncompressedSize);

                stream.Seek(
                    repeatedByteSize,
                    SeekOrigin.Current);

                stream.Write(
                    Uncompressable,
                    leftUncompressedSize,
                    rightUncompressedSize);

                stream.WriteByte(0xFF);
            }

            replacedertCompressionQuality(
                uncompressedData,
                expectedCompressedData);
        }

public void AddData(byte data)
		{
			_newEntry.WriteByte(data);
		}

[Run("compress=null pgsz=1024  cnt=2000")]
    [Run("compress=null pgsz=16000 cnt=2000")]
    [Run("compress=gzip pgsz=1024  cnt=2000")]
    [Run("compress=gzip pgsz=16000 cnt=2000")]
    public void Corrupt_Volume_Read(string compress, int pgsz, int cnt)
    {
      var ms = new MemoryStream();
      var meta = VolumeMetadataBuilder.Make("String archive", StringArchiveAppender.CONTENT_TYPE_STRING)
                                      .SetVersion(1, 0)
                                      .SetDescription("Testing string messages")
                                      .SetChannel(Atom.Encode("dvop"))
                                      .SetCompressionScheme(compress);

      var volume = new DefaultVolume(NOPApplication.Instance.SecurityManager.Cryptography, meta, ms)
      {
          PageSizeBytes = pgsz
      };

      using(var appender = new StringArchiveAppender(volume, NOPApplication.Instance.TimeSource, new Atom(65), "[email protected]"))
      {
        for(var i=0; i<cnt; i++)
        {
          appender.Append("string-data--------------------------------------------------------" + i.ToString());
        }
      }

      "Volume size is {0:n0} bytes".SeeArgs(ms.Length);

      var reader = new StringArchiveReader(volume);

      var allCount = reader.All.Count();
      Aver.AreEqual(cnt, allCount);

      reader.All.ForEach( (s, i) => Aver.IsTrue(s.EndsWith("---" + i.ToString())));

      var pageCount = reader.GetPagesStartingAt(0).Count();
      Aver.IsTrue(pageCount > 0);

      "Before corruption: there are {0:n0} total records in {1:n0} pages".SeeArgs(allCount, pageCount);

      var midPoint = ms.Length / 2;
      ms.Position = midPoint;
      for(var j=0; j<pgsz*2; j++) ms.WriteByte(0x00);//corruption

      "-------------- corrupted {0:n0} bytes of {1:n0} total at {2:n0} position -----------  ".SeeArgs(pgsz*2, ms.Length, midPoint);

      var allCount2 = reader.GetEntriesStartingAt(new Bookmark(), skipCorruptPages: true).Count();
      Aver.IsTrue( allCount > allCount2);

      var pageCount2 = reader.GetPagesStartingAt(0, skipCorruptPages: true).Count();
      Aver.IsTrue(pageCount > pageCount2);

      "After corruption: there are {0:n0} total records in {1:n0} pages".SeeArgs(allCount2, pageCount2);

      volume.Dispose();
    }

public void AddLeShort(int toAdd)
		{
			unchecked {
				_newEntry.WriteByte(( byte )toAdd);
				_newEntry.WriteByte(( byte )(toAdd >> 8));
			}
		}

private void WriteType(MemoryStream ms, Type type)
        {
            var typeName = TypeHelper.BuildTypeName(type);
            var typeArray = Encoding.UTF8.GetBytes(typeName);

            var len = typeArray.Length;
            // BinaryWrite Int32
            ms.WriteByte((byte)len);
            ms.WriteByte((byte)(len >> 8));
            ms.WriteByte((byte)(len >> 16));
            ms.WriteByte((byte)(len >> 24));
            // BinaryWrite String
            ms.Write(typeArray, 0, len);
        }

internal async Task<byte[]> ReadPacket(USBDevice device, byte[] packet)
        {
            var input = new MemoryStream();

            for (int i = 0; i < packet.Length; i++)
            {
                var readedByte = packet[i];
                if (readedByte == PinPadConstants.ACK || readedByte == PinPadConstants.NAK) continue;
                input.WriteByte(readedByte);

                if (readedByte == PinPadConstants.SYN) continue;

                if (readedByte == PinPadConstants.ETB)
                {
                    var data = input.ToArray().Skip(1).ToArray();
                    await device.TransferOut(2, new byte[] { PinPadConstants.ACK });
                    return data.Take(data.Length - 1).ToArray();
                }
            }
            return null;
        }

public void WriteValue(bool value)
        {
            Stream.WriteByte((byte)(value ? 1 : 0));
        }

public static byte[] FrameData(byte[] payload, FrameType frameType)
        {
            var memoryStream = new MemoryStream();
            byte op = (byte)((byte)frameType + 128);
            
            memoryStream.WriteByte(op);
            
            if (payload.Length > UInt16.MaxValue) {
                memoryStream.WriteByte(127);
                var lengthBytes = payload.Length.ToBigEndianBytes<ulong>();
                memoryStream.Write(lengthBytes, 0, lengthBytes.Length);
            } else if (payload.Length > 125) {
                memoryStream.WriteByte(126);
                var lengthBytes = payload.Length.ToBigEndianBytes<ushort>();
                memoryStream.Write(lengthBytes, 0, lengthBytes.Length);
            } else {
                memoryStream.WriteByte((byte)payload.Length);
            }
            
            memoryStream.Write(payload, 0, payload.Length);
            
            return memoryStream.ToArray();
        }

public void End()
        {
            Stream.WriteByte(0xFF);
        }

private void button6_Click(object sender, EventArgs e)
    {
      var message = string.Empty;
      var value = 1999;
      var timer = new Stopwatch();
      using (var stream = new MemoryStream())
      {
        timer.Start();
        var buffer = new byte[4];
        for (int i=0; i<10000000; i++)
        {
          buffer[0] = (byte)value;
          buffer[1] = (byte)(value >> 8);
          buffer[2] = (byte)(value >> 16);
          buffer[3] = (byte)(value >> 24);
          stream.Write(buffer, 0, 4);
        }
        timer.Stop();
        message += "Writing int as byte array to stream (10000000 iters): " + timer.ElapsedMilliseconds;
      }

      timer.Reset();
      using (var stream = new MemoryStream())
      {
        timer.Start();
        for (int i=0; i<10000000; i++)
        {
          stream.WriteByte((byte)value);
          stream.WriteByte((byte)(value >> 8));
          stream.WriteByte((byte)(value >> 16));
          stream.WriteByte((byte)(value >> 34));
        }
        timer.Stop();
        message +=  Environment.NewLine + "Writing int byte by byte to stream (10000000 iters): " + timer.ElapsedMilliseconds;
      }

      label3.Text = message;
    }

internal void EndWriting()
    {
      Ensure(Status.Writing);
      m_Raw.WriteByte(Format.ENTRY_HEADER_EOF_1);
      m_Raw.WriteByte(Format.ENTRY_HEADER_EOF_2);

      //varbit entry header padding
      m_Raw.WriteByte(0xAA);
      m_Raw.WriteByte(0xAA);
      m_Raw.WriteByte(0xAA);

      m_State = Status.Written;
    }

public static byte[] PBKDF2Sha512GetBytes(int dklen, byte[] preplacedword, byte[] salt, int iterationCount)
        {
            using (var hmac = new HMACSHA512(preplacedword))
            {
                int hashLength = hmac.HashSize / 8;
                if ((hmac.HashSize & 7) != 0)
                    hashLength++;
                int keyLength = dklen / hashLength;
                if (dklen > (0xFFFFFFFFL * hashLength) || dklen < 0)
                {
                    throw new ArgumentOutOfRangeException("dklen");
                }
                if (dklen % hashLength != 0)
                {
                    keyLength++;
                }
                byte[] extendedkey = new byte[salt.Length + 4];
                Buffer.BlockCopy(salt, 0, extendedkey, 0, salt.Length);
                using (var ms = new MemoryStream())
                {
                    for (int i = 0; i < keyLength; i++)
                    {
                        extendedkey[salt.Length] = (byte)(((i + 1) >> 24) & 0xFF);
                        extendedkey[salt.Length + 1] = (byte)(((i + 1) >> 16) & 0xFF);
                        extendedkey[salt.Length + 2] = (byte)(((i + 1) >> 8) & 0xFF);
                        extendedkey[salt.Length + 3] = (byte)(((i + 1)) & 0xFF);
                        byte[] u = hmac.ComputeHash(extendedkey);
                        Array.Clear(extendedkey, salt.Length, 4);
                        byte[] f = u;
                        for (int j = 1; j < iterationCount; j++)
                        {
                            u = hmac.ComputeHash(u);
                            for (int k = 0; k < f.Length; k++)
                            {
                                f[k] ^= u[k];
                            }
                        }
                        ms.Write(f, 0, f.Length);
                        Array.Clear(u, 0, u.Length);
                        Array.Clear(f, 0, f.Length);
                    }
                    byte[] dk = new byte[dklen];
                    ms.Position = 0;
                    ms.Read(dk, 0, dklen);
                    ms.Position = 0;
                    for (long i = 0; i < ms.Length; i++)
                    {
                        ms.WriteByte(0);
                    }
                    Array.Clear(extendedkey, 0, extendedkey.Length);
                    return dk;
                }
            }
        }

private static void WriteTag(this MemoryStream mem, int tag)
        {
            mem.WriteByte((byte)tag);
        }

public void WriteValue(byte value)
        {
            Stream.WriteByte(value);
        }

internal static Stream HexStringToMemoryStream(string hex)
            {
                var stream = new MemoryStream(hex.Length / 2);
                for (var i = 0; i < hex.Length; i += 2)
                    stream.WriteByte(Convert.ToByte(hex.Substring(i, 2), 16));
                return stream;
            }

protected static byte[] FilterWithEnglishLetters(byte[] buf, int offset, int len)
        {
            byte[] result;

            using (MemoryStream ms = new MemoryStream(buf.Length))
            {

                bool inTag = false;
                int max = offset + len;
                int prev = offset;
                int cur = offset;

                while (cur < max)
                {

                    byte b = buf[cur];

                    if (b == GREATER_THAN)
                        inTag = false;
                    else if (b == LESS_THAN)
                        inTag = true;

                    // it's ascii, but it's not a letter
                    if ((b & 0x80) == 0 && (b < CAPITAL_A || b > SMALL_Z
                           || (b > CAPITAL_Z && b < SMALL_A)))
                    {
                        if (cur > prev && !inTag)
                        {
                            ms.Write(buf, prev, cur - prev);
                            ms.WriteByte(SPACE);
                        }
                        prev = cur + 1;
                    }
                    cur++;
                }

                // If the current segment contains more than just a symbol 
                // and it is not inside a tag then keep it.
                if (!inTag && cur > prev)
                    ms.Write(buf, prev, cur - prev);
                ms.SetLength(ms.Position);
                result = ms.ToArray();
            }
            return result;
        }

public byte[] Serialize()
        {
            byte[] accountAddressesLength = ShortVectorEncoding.EncodeLength(AccountKeys.Count);
            byte[] instructionsLength = ShortVectorEncoding.EncodeLength(Instructions.Count);
            int accountKeysBufferSize = AccountKeys.Count * 32;

            MemoryStream accountKeysBuffer = new(accountKeysBufferSize);

            foreach (PublicKey key in AccountKeys)
            {
                accountKeysBuffer.Write(key.KeyBytes);
            }

            int messageBufferSize = MessageHeader.Layout.HeaderLength + PublicKey.PublicKeyLength +
                                    accountAddressesLength.Length +
                                    +instructionsLength.Length + Instructions.Count + accountKeysBufferSize;
            MemoryStream buffer = new(messageBufferSize);
            buffer.Write(Header.ToBytes());
            buffer.Write(accountAddressesLength);
            buffer.Write(accountKeysBuffer.ToArray());
            buffer.Write(Encoders.Base58.DecodeData(RecentBlockhash));
            buffer.Write(instructionsLength);

            foreach (CompiledInstruction compiledInstruction in Instructions)
            {
                buffer.WriteByte(compiledInstruction.ProgramIdIndex);
                buffer.Write(compiledInstruction.KeyIndicesCount);
                buffer.Write(compiledInstruction.KeyIndices);
                buffer.Write(compiledInstruction.DataLength);
                buffer.Write(compiledInstruction.Data);
            }
            return buffer.ToArray();
        }

public byte[] Close()
        {
            Stream.WriteByte(0xFF);
            Stream.WriteByte(0xFF);
            Buffer = Stream.ToArray();
            Stream.Dispose();
            return Buffer;
        }

internal static byte [] UrlDecodeToBytesInternally (byte [] bytes, int offset, int count)
    {
      using (var res = new MemoryStream ()) {
        var end = offset + count;
        for (int i = offset; i < end; i++) {
          var c = (char) bytes [i];
          if (c == '+') {
            c = ' ';
          }
          else if (c == '%' && i < end - 2) {
            var xchar = getChar (bytes, i + 1, 2);
            if (xchar != -1) {
              c = (char) xchar;
              i += 2;
            }
          }

          res.WriteByte ((byte) c);
        }

        res.Close ();
        return res.ToArray ();
      }
    }

private static void DecompressChunk(MemoryStream ms, byte[] compBuffer, ref int pos)
        {
            ushort header = BitConverter.ToUInt16(compBuffer, pos);
            int decomprPos = 0;
            byte[] buffer = new byte[4198]; //Add an extra 100 byte. Some workbooks have overflowing worksheets.
            int size = (int)(header & 0xFFF) + 3;
            int endPos = pos + size;
            int a = (int)(header & 0x7000) >> 12;
            int b = (int)(header & 0x8000) >> 15;
            pos += 2;
            if (b == 1) //Compressed chunk
            {
                while (pos < compBuffer.Length && pos < endPos)
                {
                    //Decompress token
                    byte token = compBuffer[pos++];
                    if (pos >= endPos)
                        break;
                    for (int i = 0; i < 8; i++)
                    {
                        //Literal token
                        if ((token & (1 << i)) == 0)
                        {
                            ms.WriteByte(compBuffer[pos]);
                            buffer[decomprPos++] = compBuffer[pos++];
                        }
                        else //copy token
                        {
                            var t = BitConverter.ToUInt16(compBuffer, pos);
                            int bitCount = GetLengthBits(decomprPos);
                            int bits = (16 - bitCount);
                            ushort lengthMask = (ushort)((0xFFFF) >> bits);
                            UInt16 offsetMask = (ushort)~lengthMask;
                            var length = (lengthMask & t) + 3;
                            var offset = (offsetMask & t) >> (bitCount);
                            int source = decomprPos - offset - 1;
                            if (decomprPos + length >= buffer.Length)
                            {
                                // Be lenient on decompression, so extend our decompression
                                // buffer. Excel generated VBA projects do encounter this issue.
                                // One would think (not surprisingly that the VBA project spec)
                                // over emphasizes the size restrictions of a DecompressionChunk.
                                var largerBuffer = new byte[buffer.Length + 4098];
                                Array.Copy(buffer, largerBuffer, decomprPos);
                                buffer = largerBuffer;
                            }

                            // Even though we've written to the MemoryStream,
                            // We still should decompress the token into this buffer
                            // in case a later token needs to use the bytes we're
                            // about to decompress.
                            for (int c = 0; c < length; c++)
                            {
                                ms.WriteByte(buffer[source]); //Must copy byte-wise because copytokens can overlap compressed buffer.
                                buffer[decomprPos++] = buffer[source++];
                            }

                            pos += 2;

                        }
                        if (pos >= endPos)
                            break;
                    }
                }
                return;
            }
            else //Raw chunk
            {
                ms.Write(compBuffer, pos, size);
                pos += size;
                return;
            }
        }

public unsafe static void SavePNG(byte* image, int width, int height, bool hasAlpha, Stream fs, FilterModes filter, int threadCount = 0)
        {
            if (threadCount == 0)
            {
                threadCount = filter == FilterModes.Adaptive ? Math.Max(1, Math.Min(width / 600, Environment.ProcessorCount - 2)) : 1;
            }

            //Header
            fs.Write(new byte[] { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }, 0, 8);

            //IHDR chunk
            fs.WriteInt(13);
            using (MemoryStream ihdr = new MemoryStream(13))
            {
                ihdr.WriteASCIIString("IHDR");
                ihdr.WriteInt(width);
                ihdr.WriteInt(height);
                ihdr.WriteByte(8); //Bit depth
                
                if (hasAlpha)
                {
                    ihdr.WriteByte(6); //Colour type
                }
                else
                {
                    ihdr.WriteByte(2); //Colour type
                }
                
                ihdr.WriteByte(0); //Compression method
                ihdr.WriteByte(0); //Filter method
                ihdr.WriteByte(0); //Interlace

                ihdr.Seek(0, SeekOrigin.Begin);
                ihdr.CopyTo(fs);

                fs.WriteUInt(CRC32.ComputeCRC(ihdr));
            }

            //IDAT chunk
            IntPtr filteredImage;
            
            if (threadCount > 1)
            {
                filteredImage = FilterImageData(image, width, height, hasAlpha ? 4 : 3, FilterModes.Adaptive, threadCount);
            }
            else
            {
                filteredImage = FilterImageData(image, width, height, hasAlpha ? 4 : 3, FilterModes.Adaptive);
            }
            
            using (MemoryStream compressedImage = StreamUtils.ZLibCompress(filteredImage, height * (width * (hasAlpha ? 4 : 3) + 1)))
            {
                compressedImage.Seek(0, SeekOrigin.Begin);
                fs.WriteUInt((uint)compressedImage.Length);
                fs.WriteASCIIString("IDAT");
                compressedImage.Seek(0, SeekOrigin.Begin);
                compressedImage.CopyTo(fs);

                fs.WriteUInt(CRC32.ComputeCRC(compressedImage.GetBuffer(), (int)compressedImage.Length, new byte[] { 73, 68, 65, 84 }));
            }

            Marshal.FreeHGlobal(filteredImage);

            //IEND chunk
            fs.WriteInt(0);
            fs.WriteASCIIString("IEND");
            fs.Write(new byte[] { 0xAE, 0x42, 0x60, 0x82 }, 0, 4);

        }

public void WriteIndex(int idx)
        {
            Stream.WriteByte((byte)idx);
        }

internal void EndWriting()
    {
      Ensure(Status.Writing);
      m_Raw.WriteByte(Format.ENTRY_HEADER_EOF_1);
      m_Raw.WriteByte(Format.ENTRY_HEADER_EOF_2);

      //varbit entry header padding
      m_Raw.WriteByte(0xAA);
      m_Raw.WriteByte(0xAA);
      m_Raw.WriteByte(0xAA);

      m_State = Status.Written;
    }

private void Filler(IntPtr data, int size)
        {
            int blockCount = _wave.BlockCount;
            byte[] b = new byte[size];

            if (_file != null && (_looped || _lastBlock < blockCount))
            {
                MemoryStream ms = new MemoryStream();

                if (_leftOverBuffer != null)
                {
                    ms.Write(_leftOverBuffer, 0, _leftOverBuffer.Length);
                }
                
                while (ms.Position < size)
                {
                    _lastBlock++;

                    if (_lastBlock >= blockCount)
                    {
                        if (!_looped)
                        {
                            while(ms.Position < size)
                            {
                                ms.WriteByte(0);
                            }
                            break;
                        }
                        else
                        {
                            _lastBlock = 0;
                            _state = new DviAdpcmDecoder.AdpcmState();
                        }
                    }

                    _file.SoundBank.ExportWaveBlockAsPCM(_wave.Index, _lastBlock, ref _state, _file.Stream, ms);
                }

                int extraData = (int)(ms.Position - size);
                
                ms.Seek(0, SeekOrigin.Begin);
                ms.Read(b, 0, size);

                if (extraData > 0)
                {
                    _leftOverBuffer = new byte[extraData];
                    ms.Read(_leftOverBuffer, 0, extraData);
                }
                else
                {
                    _leftOverBuffer = null;
                }
            }
            else
            {
                for (int i = 0; i < b.Length; i++)
                {
                    b[i] = 0;
                }
            }
            System.Runtime.InteropServices.Marshal.Copy(b, 0, data, size);
        }

private void m_btnStream_Click(object sender, EventArgs e)
    {
      var buf = new byte[317];
      using (var ms = new MemoryStream(buf))
      {
        ms.WriteByte(14);
        ms.SetLength(40);
        ms.SetLength(310);
      }

      MessageBox.Show(buf[0].ToString(), "");
    }

public int Append(ArraySegment<byte> entry)
    {
      Ensure(Status.Writing);
      Aver.IsTrue(entry.Array != null && entry.Count > 0);

      var addr = (int)m_Raw.Position;

      Aver.IsTrue(entry.Count < Format.ENTRY_MAX_LEN, "exceeded ENTRY_MAX_LEN");
      Aver.IsTrue(addr + entry.Count < Format.PAGE_MAX_BUFFER_LEN, "exceeded PAGE_MAX_BUFFER_LEN");

      m_Raw.WriteByte(Format.ENTRY_HEADER_1);
      m_Raw.WriteByte(Format.ENTRY_HEADER_2);
      writeVarLength(m_Raw, entry.Count);

      m_Raw.Write(entry.Array, entry.Offset, entry.Count);

      return addr;
    }

static public void SaveToICNS(Drawing drawing, List<int> sizes, string filename)
        {
            int headerLen = 8;
            int fileLen = headerLen;
            using (var icoStream = new MemoryStream())
            {
                icoStream.WriteByte(0x69);
                icoStream.WriteByte(0x63);
                icoStream.WriteByte(0x6e);
                icoStream.WriteByte(0x73);
                
                icoStream.Position = headerLen;

                for (int i = 0; i < sizes.Count; i++)
                {
                    var start = icoStream.Position;
                    icoStream.Position += 8;
                    SaveDrawing(drawing, sizes[i], icoStream);
                    var end = icoStream.Position;
                    int pngLen = (int)(end - start);
                    fileLen += pngLen;

                    icoStream.Position = start;
                    string iconType;
                    switch(sizes[i])
                    {
                        case 16: iconType = "icp4"; break;
                        case 32: iconType = "icp5"; break;
                        case 64: iconType = "icp6"; break;
                        case 128: iconType = "ic07"; break;
                        case 256: iconType = "ic08"; break;
                        case 512: iconType = "ic09"; break;
                        default: throw new Exception($"Unsupported icns size {sizes[i]}");
                    }
                    icoStream.Write(ASCIIEncoding.ASCII.GetBytes(iconType));

                    icoStream.WriteByte((byte)(pngLen >> 24));
                    icoStream.WriteByte((byte)((pngLen >> 16) & 0xff));
                    icoStream.WriteByte((byte)((pngLen >> 8) & 0xff));
                    icoStream.WriteByte((byte)(pngLen & 0xff));
                    
                    icoStream.Position = end;
                }
                icoStream.Position = 4;

                icoStream.WriteByte((byte)(fileLen >> 24));
                icoStream.WriteByte((byte)((fileLen >> 16) & 0xff));
                icoStream.WriteByte((byte)((fileLen >> 8) & 0xff));
                icoStream.WriteByte((byte)(fileLen & 0xff));
                
                using (var icoFile = File.Create(filename))
                {
                    icoFile.Write(icoStream.GetBuffer(), 0, fileLen);
                }
            }
        }

[Run]
    public void EncodeToStreamDecode()
    {
      var partField = getDefaultField();
      var partFile = getDefaultFile();

      var stream = new MemoryStream();
      stream.WriteByte(0xFF);
      stream.WriteByte(0xFF);

      var mpE = new Multipart(new Multipart.Part[] { partField, partFile });
      var enc = mpE.Encode(stream);
      Aver.AreEqual(enc.StartIdx, 2);

      var src = new byte[enc.Length];
      Array.Copy(enc.Buffer, enc.StartIdx, src, 0, src.Length);

      string boundary = null;
      var mpD = Multipart.ReadFromBytes(src, ref boundary);

      Aver.AreEqual(enc.Boundary, boundary);
      Aver.AreEqual(partField.Content.replacedtring(), mpD.Parts[partField.Name].Content.replacedtring());
      Aver.IsNull(mpD.Parts[partField.Name].ContentType);
      Aver.IsNull(mpD.Parts[partField.Name].FileName);
      Aver.AreEqual(partFile.FileName, mpD.Parts[partFile.Name].FileName);
      Aver.AreEqual(partFile.ContentType, mpD.Parts[partFile.Name].ContentType);
      Aver.IsTrue(IOUtils.MemBufferEquals(partFile.Content as byte[], mpD.Parts[partFile.Name].Content as byte[]));
    }

public void WriteByteValue(byte value)
        {
            Stream.WriteByte(value);
        }

private static void WriteLength(this MemoryStream mem, int length)
        {
            if (length > 127)
            {
                int size = 1;
                uint val = (uint)length;

                while ((val >>= 8) != 0)
                {
                    size++;
                }

                mem.WriteByte((byte)(size | 0x80));

                for (int i = (size - 1) * 8; i >= 0; i -= 8)
                {
                    mem.WriteByte((byte)(length >> i));
                }
            }
            else
            {
                mem.WriteByte((byte)length);
            }
        }

internal byte[] Build()
        {
            if (RecentBlockHash == null) 
                // werent we supposed to fetch it from the api in this case?
                throw new Exception("recent block hash is required");
            if (_instructions == null) 
                throw new Exception("no instructions provided in the transaction");

            _messageHeader = new MessageHeader();
            
            var keysList = GetAccountKeys();
            var accountAddressesLength = ShortVectorEncoding.EncodeLength(keysList.Count);
            var compiledInstructionsLength = 0;
            var compiledInstructions = new List<CompiledInstruction>();

            foreach (var instruction in _instructions)
            {
                var keyCount = instruction.Keys.Count;
                var keyIndices = new byte[keyCount];

                for (var i = 0; i < keyCount; i++)
                {
                    keyIndices[i] = (byte) FindAccountIndex(keysList, instruction.Keys[i].PublicKey);
                }

                var compiledInstruction = new CompiledInstruction
                {
                    ProgramIdIndex = (byte) FindAccountIndex(keysList, instruction.ProgramId),
                    KeyIndicesCount = ShortVectorEncoding.EncodeLength(keyCount),
                    KeyIndices = keyIndices,
                    DataLength = ShortVectorEncoding.EncodeLength(instruction.Data.Length),
                    Data = instruction.Data
                };
                compiledInstructions.Add(compiledInstruction);
                compiledInstructionsLength += compiledInstruction.Length();
            }


            var accountKeysBufferSize = _accountKeysList.AccountList.Count * 32;
            var accountKeysBuffer = new MemoryStream(accountKeysBufferSize);
            var instructionsLength = ShortVectorEncoding.EncodeLength(compiledInstructions.Count);
            
            foreach (var accountMeta in keysList)
            {
                accountKeysBuffer.Write(accountMeta.PublicKey,0, accountMeta.PublicKey.Length);
                if (accountMeta.Signer)
                {
                    _messageHeader.RequiredSignatures += 1;
                    if (!accountMeta.Writable)
                        _messageHeader.ReadOnlySignedAccounts += 1;
                }
                else 
                {
                    if (!accountMeta.Writable)
                        _messageHeader.ReadOnlyUnsignedAccounts += 1;
                }
            }

            #region Build Message Body

            
            var messageBufferSize = MessageHeader.HeaderLength + BlockHashLength + accountAddressesLength.Length +
                                    + instructionsLength.Length + compiledInstructionsLength + accountKeysBufferSize;
            var buffer = new MemoryStream(messageBufferSize);
            var messageHeaderBytes = _messageHeader.ToBytes();

            buffer.Write(messageHeaderBytes, 0, messageHeaderBytes.Length);
            buffer.Write(accountAddressesLength, 0, accountAddressesLength.Length);
            buffer.Write(accountKeysBuffer.ToArray(),0, accountKeysBuffer.ToArray().Length);
            buffer.Write(Base58Encoding.Decode(RecentBlockHash),0, Base58Encoding.Decode(RecentBlockHash).Length);
            buffer.Write(instructionsLength, 0, instructionsLength.Length);
            
            foreach (var compiledInstruction in compiledInstructions)
            {
                buffer.WriteByte(compiledInstruction.ProgramIdIndex);
                buffer.Write(compiledInstruction.KeyIndicesCount, 0, compiledInstruction.KeyIndicesCount.Length);
                buffer.Write(compiledInstruction.KeyIndices,0, compiledInstruction.KeyIndices.Length);
                buffer.Write(compiledInstruction.DataLength,0, compiledInstruction.DataLength.Length);
                buffer.Write(compiledInstruction.Data,0, compiledInstruction.Data.Length);
            }

            #endregion
            
            return buffer.ToArray();
        }

internal static byte[] Serialize(KeyPath keyPath)
        {
            replacedertKeyPath(keyPath);
            MemoryStream memoryStream = new MemoryStream();
            memoryStream.WriteByte((byte) keyPath.Indexes.Length);
            for (int index = 0; index < keyPath.Indexes.Length; ++index)
            {
                byte[] bytes = ToBytes(keyPath.Indexes[index], false);
                memoryStream.Write(bytes, 0, bytes.Length);
            }
            return memoryStream.ToArray();
        }

public override System.Windows.DataObject CreateDataObject(TextArea textArea)
		{
			var data = base.CreateDataObject(textArea);

			if (EditingCommandHandler.ConfirmDataFormat(textArea, data, RectangularSelectionDataType)) {
				MemoryStream isRectangle = new MemoryStream(1);
				isRectangle.WriteByte(1);
				data.SetData(RectangularSelectionDataType, isRectangle, false);
			}
			return data;
		}

public static Cursor CreateCursor(double rx, double ry, SolidColorBrush brush, Pen pen)
        {
            var vis = new DrawingVisual();
            using (var dc = vis.RenderOpen())
            {
                dc.DrawRectangle(brush, new Pen(Brushes.Black, 0.1), new Rect(0, 0, rx, ry));
                dc.Close();
            }
            var rtb = new RenderTargetBitmap(64, 64, 96, 96, PixelFormats.Pbgra32);
            rtb.Render(vis);

            using (var ms1 = new MemoryStream())
            {
                var penc = new PngBitmapEncoder();
                penc.Frames.Add(BitmapFrame.Create(rtb));
                penc.Save(ms1);

                var pngBytes = ms1.ToArray();
                var size = pngBytes.GetLength(0);

                //.cur format spec http://en.wikipedia.org/wiki/ICO_(file_format)
                using (var ms = new MemoryStream())
                {
                    {
                        //ICONDIR Structure
                        ms.Write(BitConverter.GetBytes((Int16)0), 0, 2); //Reserved must be zero; 2 bytes
                        ms.Write(BitConverter.GetBytes((Int16)2), 0, 2); //image type 1 = ico 2 = cur; 2 bytes
                        ms.Write(BitConverter.GetBytes((Int16)1), 0, 2); //number of images; 2 bytes
                    }

                    {
                        //ICONDIRENTRY structure
                        ms.WriteByte(32); //image width in pixels
                        ms.WriteByte(32); //image height in pixels

                        ms.WriteByte(0); //Number of Colors in the color palette. Should be 0 if the image doesn't use a color palette
                        ms.WriteByte(0); //reserved must be 0

                        ms.Write(BitConverter.GetBytes((Int16)(rx / 2.0)), 0, 2); //2 bytes. In CUR format: Specifies the horizontal coordinates of the hotspot in number of pixels from the left.
                        ms.Write(BitConverter.GetBytes((Int16)(ry / 2.0)), 0, 2); //2 bytes. In CUR format: Specifies the vertical coordinates of the hotspot in number of pixels from the top.

                        ms.Write(BitConverter.GetBytes(size), 0, 4); //Specifies the size of the image's data in bytes
                        ms.Write(BitConverter.GetBytes((Int32)22), 0, 4); //Specifies the offset of BMP or PNG data from the beginning of the ICO/CUR file
                    }

                    ms.Write(pngBytes, 0, size); //write the png data.
                    ms.Seek(0, SeekOrigin.Begin);
                    return new Cursor(ms);
                }
            }
        }

protected static byte[] FilterWithoutEnglishLetters(byte[] buf, int offset, int len)
        {
            byte[] result;

            using (MemoryStream ms = new MemoryStream(buf.Length))
            {
                bool meetMSB = false;
                int max = offset + len;
                int prev = offset;
                int cur = offset;

                while (cur < max)
                {
                    byte b = buf[cur];

                    if ((b & 0x80) != 0)
                    {
                        meetMSB = true;
                    }
                    else if (b < CAPITAL_A || (b > CAPITAL_Z && b < SMALL_A) || b > SMALL_Z)
                    {
                        if (meetMSB && cur > prev)
                        {
                            ms.Write(buf, prev, cur - prev);
                            ms.WriteByte(SPACE);
                            meetMSB = false;
                        }
                        prev = cur + 1;
                    }
                    cur++;
                }

                if (meetMSB && cur > prev)
                    ms.Write(buf, prev, cur - prev);
                ms.SetLength(ms.Position);
                result = ms.ToArray();
            }
            return result;
        }

private async Task<byte[]> WritePacket(USBDevice device, byte[] data)
        {
            var toCRC = new MemoryStream();
            await toCRC.WriteAsync(data, 0, data.Length);
            toCRC.WriteByte(PinPadConstants.ETB);
            var crc = toCRC.ToArray().ComputeCRC16();

            // <SYN>[MESSAGE]<ETB>{CRC}
            var output = new MemoryStream();
            output.WriteByte(PinPadConstants.SYN); //<SYN>
            await output.WriteAsync(data, 0, data.Length); //[MESSAGE]
            output.WriteByte(PinPadConstants.ETB); //<ETB>
            await output.WriteAsync(crc, 0, crc.Length); //{CRC}

            var outputData = output.ToArray();
            this._logger.LogInformation($"{PinPadConstants.APP_TO_PINPAD} {PacketToString(outputData)}");

            var trxResult = await device.TransferOut(2, outputData);

            if (trxResult.Status != USBTransferStatus.OK)
            {
                this._logger.LogWarning("NOT OK!!!");
                this._logger.LogWarning(trxResult);
            }
            this._logger.LogInformation(trxResult);
            int sendFailures = 0;
            var readResult = await device.TransferIn(1, 64);
            this._logger.LogInformation(readResult);
            var read = readResult.Data[0];

            while (read == PinPadConstants.NAK && sendFailures < 3)
            {
                this._logger.LogInformation($"{PinPadConstants.PINPAD_TO_APP} {PinPadConstants.NAK_STR}");
                trxResult = await device.TransferOut(2, outputData);
                if (trxResult.Status != USBTransferStatus.OK)
                {
                    this._logger.LogWarning("WRITE NOT OK!!!");
                    this._logger.LogWarning(trxResult);
                }
                readResult = await device.TransferIn(1, 64);
                if (readResult.Status != USBTransferStatus.OK)
                {
                    this._logger.LogWarning("READ NOT OK!!!");
                    this._logger.LogWarning(readResult);
                }
                read = readResult.Data[0];
                sendFailures++;
                this._logger.LogInformation($"Failures: {sendFailures}");
            }

            if (read != PinPadConstants.ACK) throw new InvalidOperationException(PinPadConstants.NAK_STR);

            this._logger.LogInformation($"{PinPadConstants.PINPAD_TO_APP} {PinPadConstants.ACK_STR}");

            var response = new MemoryStream();

            if (readResult.Data.Length > 1 && readResult.Data.Length < 64)
            {
                await response.WriteAsync(readResult.Data, 0, readResult.Data.Length);
            }
            else
            {
                do
                {
                    this._logger.LogInformation($"Reading mode data...");
                    readResult = await device.TransferIn(1, 64);
                    await response.WriteAsync(readResult.Data, 0, readResult.Data.Length);
                } while (readResult.Data.Length == 64);
            }

            this._logger.LogInformation($"Data length: {response.Length}");

            return await ReadPacket(device, response.ToArray());
        }

public void WriteValue(byte* addr, int size)
        {
            for (var idx = 0; idx < size; idx++) Stream.WriteByte(*(addr + idx));
        }

internal byte[] Build()
        {
            if (RecentBlockHash == null && NonceInformation == null)
                throw new Exception("recent block hash or nonce information is required");
            if (Instructions == null)
                throw new Exception("no instructions provided in the transaction");

            // In case the user specified nonce information, we'll use it.
            if (NonceInformation != null)
            {
                RecentBlockHash = NonceInformation.Nonce;
                _accountKeysList.Add(NonceInformation.Instruction.Keys);
                _accountKeysList.Add(AccountMeta.ReadOnly(new PublicKey(NonceInformation.Instruction.ProgramId),
                    false));
                List<TransactionInstruction> newInstructions = new() { NonceInformation.Instruction };
                newInstructions.AddRange(Instructions);
                Instructions = newInstructions;
            }

            _messageHeader = new MessageHeader();

            List<AccountMeta> keysList = GetAccountKeys();
            byte[] accountAddressesLength = ShortVectorEncoding.EncodeLength(keysList.Count);
            int compiledInstructionsLength = 0;
            List<CompiledInstruction> compiledInstructions = new();

            foreach (TransactionInstruction instruction in Instructions)
            {
                int keyCount = instruction.Keys.Count;
                byte[] keyIndices = new byte[keyCount];

                for (int i = 0; i < keyCount; i++)
                {
                    keyIndices[i] = (byte)FindAccountIndex(keysList, instruction.Keys[i].PublicKeyBytes);
                }

                CompiledInstruction compiledInstruction = new CompiledInstruction
                {
                    ProgramIdIndex = (byte)FindAccountIndex(keysList, instruction.ProgramId),
                    KeyIndicesCount = ShortVectorEncoding.EncodeLength(keyCount),
                    KeyIndices = keyIndices,
                    DataLength = ShortVectorEncoding.EncodeLength(instruction.Data.Length),
                    Data = instruction.Data
                };
                compiledInstructions.Add(compiledInstruction);
                compiledInstructionsLength += compiledInstruction.Length();
            }

            int accountKeysBufferSize = _accountKeysList.AccountList.Count * 32;
            MemoryStream accountKeysBuffer = new MemoryStream(accountKeysBufferSize);
            byte[] instructionsLength = ShortVectorEncoding.EncodeLength(compiledInstructions.Count);

            foreach (AccountMeta accountMeta in keysList)
            {
                accountKeysBuffer.Write(accountMeta.PublicKeyBytes);
                if (accountMeta.IsSigner)
                {
                    _messageHeader.RequiredSignatures += 1;
                    if (!accountMeta.IsWritable)
                        _messageHeader.ReadOnlySignedAccounts += 1;
                }
                else
                {
                    if (!accountMeta.IsWritable)
                        _messageHeader.ReadOnlyUnsignedAccounts += 1;
                }
            }

            #region Build Message Body

            int messageBufferSize = MessageHeader.Layout.HeaderLength + BlockHashLength +
                                    accountAddressesLength.Length +
                                    +instructionsLength.Length + compiledInstructionsLength + accountKeysBufferSize;
            MemoryStream buffer = new MemoryStream(messageBufferSize);
            byte[] messageHeaderBytes = _messageHeader.ToBytes();

            buffer.Write(messageHeaderBytes);
            buffer.Write(accountAddressesLength);
            buffer.Write(accountKeysBuffer.ToArray());
            buffer.Write(Encoders.Base58.DecodeData(RecentBlockHash));
            buffer.Write(instructionsLength);

            foreach (CompiledInstruction compiledInstruction in compiledInstructions)
            {
                buffer.WriteByte(compiledInstruction.ProgramIdIndex);
                buffer.Write(compiledInstruction.KeyIndicesCount);
                buffer.Write(compiledInstruction.KeyIndices);
                buffer.Write(compiledInstruction.DataLength);
                buffer.Write(compiledInstruction.Data);
            }

            #endregion

            return buffer.ToArray();
        }

private static byte[] urlDecodeToBytes (byte[] bytes, int offset, int count)
    {
      using (var buff = new MemoryStream ()) {
        var end = offset + count - 1;
        for (var i = offset; i <= end; i++) {
          var b = bytes[i];

          var c = (char) b;
          if (c == '%') {
            if (i > end - 2)
              break;

            var num = getNumber (bytes, i + 1, 2);
            if (num == -1)
              break;

            buff.WriteByte ((byte) num);
            i += 2;

            continue;
          }

          if (c == '+') {
            buff.WriteByte ((byte) ' ');
            continue;
          }

          buff.WriteByte (b);
        }

        buff.Close ();
        return buff.ToArray ();
      }
    }

[TestMethod]
        public void RepeatedBetweenUncomppressableLongTotal()
        {
            /*
            We run into more edge case pain when one or both sides of uncompressable data is over 32 bytes, when we get into long commands.

            When both sides are uncompressable, each side is less than 32 bytes, but the total section size is greater than 32 bytes, inserting the repeated byte copy saves space.

            data:   [n <= 0x20 bytes] 00 00 00 [m <= 0x20 bytes] : n + m + 3 > 0x20
            best:   0n [n bytes]|22 00|0m [m bytes] = (1 + n) + 2 +(1 + m) bytes
            alt:    xx xx [n + m + 3 bytes]         =  2 +(n + m + 3) bytes
            */

            // Specify the sizes of the uncompressed data's left and right uncompressable sequences.
            var leftUncompressedSize = 0x10;
            var repeatedByteSize = 3;
            var rightUncompressedSize = 0x10;

            var uncompressedData = CreateRepeatedBetweenUncompressable(
                leftUncompressedSize,
                repeatedByteSize,
                rightUncompressedSize);

            var leftCompressedSize = leftUncompressedSize + 1;
            var rightCompressedSize = rightUncompressedSize + 1;

            var compressedSize = leftCompressedSize
                + 2
                + rightCompressedSize
                + 1;

            var expectedCompressedData = new byte[compressedSize];
            using (var stream = new MemoryStream(expectedCompressedData))
            {
                stream.WriteByte(
                    (byte)(leftUncompressedSize - 1));

                stream.Write(
                    Uncompressable,
                    0,
                    leftUncompressedSize);

                stream.WriteByte(
                    (byte)(0x20 | (repeatedByteSize - 1)));

                stream.Seek(1, SeekOrigin.Current);

                stream.WriteByte(
                    (byte)(rightUncompressedSize - 1));

                stream.Write(
                    Uncompressable,
                    leftUncompressedSize,
                    rightUncompressedSize);

                stream.WriteByte(0xFF);
            }

            replacedertCompressionQuality(
                uncompressedData,
                expectedCompressedData);
        }

public static byte[] Compress(byte[] inputBytes)
        {

            MemoryStream inStream = new MemoryStream(inputBytes);
            MemoryStream outStream = new MemoryStream();
            Encoder encoder = new Encoder();
            encoder.SetCoderProperties(propIDs, properties);
            encoder.WriteCoderProperties(outStream);
            long fileSize = inStream.Length;
            for (int i = 0; i < 8; i++)
                outStream.WriteByte((Byte)(fileSize >> (8 * i)));
            encoder.Code(inStream, outStream, -1, -1, null);
            return outStream.ToArray();
        }

internal static string UrlDecodeInternally (
      byte [] bytes, int offset, int count, Encoding encoding)
    {
      var output = new StringBuilder ();
      using (var acc = new MemoryStream ()) {
        var end = count + offset;

        int xchar;
        for (int i = offset; i < end; i++) {
          if (bytes [i] == '%' && i + 2 < count && bytes [i + 1] != '%') {
            if (bytes [i + 1] == (byte) 'u' && i + 5 < end) {
              if (acc.Length > 0) {
                output.Append (getChars (acc, encoding));
                acc.SetLength (0);
              }

              xchar = getChar (bytes, i + 2, 4);
              if (xchar != -1) {
                output.Append ((char) xchar);
                i += 5;

                continue;
              }
            }
            else if ((xchar = getChar (bytes, i + 1, 2)) != -1) {
              acc.WriteByte ((byte) xchar);
              i += 2;

              continue;
            }
          }

          if (acc.Length > 0) {
            output.Append (getChars (acc, encoding));
            acc.SetLength (0);
          }

          if (bytes [i] == '+')
            output.Append (' ');
          else
            output.Append ((char) bytes [i]);
        }

        if (acc.Length > 0)
          output.Append (getChars (acc, encoding));
      }

      return output.ToString ();
    }

public void AddLeShort(int toAdd)
		{
			unchecked {
				_newEntry.WriteByte((byte)toAdd);
				_newEntry.WriteByte((byte)(toAdd >> 8));
			}
		}

public void Begin(TsonDataType type= TsonDataType.Object)
        {
            Stream.WriteByte(Ver);
            Stream.WriteByte((byte)type);
        }

override public void WriteByte(byte value)
        {
            base.WriteByte(value);
        }

static bool CopyWholeLine(TextArea textArea, DoreplacedentLine line)
		{
			ISegment wholeLine = new SimpleSegment(line.Offset, line.TotalLength);
			string text = textArea.Doreplacedent.GetText(wholeLine);
			// Ensure we use the appropriate newline sequence for the OS
			text = TextUtilities.NormalizeNewLines(text, Environment.NewLine);
			DataObject data = new DataObject();
			if (ConfirmDataFormat(textArea, data, DataFormats.UnicodeText))
				data.SetText(text);

			// Also copy text in HTML format to clipboard - good for pasting text into Word
			// or to the SharpDevelop forums.
			if (ConfirmDataFormat(textArea, data, DataFormats.Html)) {
				IHighlighter highlighter = textArea.GetService(typeof(IHighlighter)) as IHighlighter;
				HtmlClipboard.SetHtml(data, HtmlClipboard.CreateHtmlFragment(textArea.Doreplacedent, highlighter, wholeLine, new HtmlOptions(textArea.Options)));
			}

			if (ConfirmDataFormat(textArea, data, LineSelectedType)) {
				MemoryStream lineSelected = new MemoryStream(1);
				lineSelected.WriteByte(1);
				data.SetData(LineSelectedType, lineSelected, false);
			}

			var copyingEventArgs = new DataObjectCopyingEventArgs(data, false);
			textArea.RaiseEvent(copyingEventArgs);
			if (copyingEventArgs.CommandCancelled)
				return false;

			try {
				Clipboard.SetDataObject(data, true);
			} catch (ExternalException) {
				// Apparently this exception sometimes happens randomly.
				// The MS controls just ignore it, so we'll do the same.
				return false;
			}
			textArea.OnTextCopied(new TextEventArgs(text));
			return true;
		}

public void WriteBoolValue(bool value)
        {
            Stream.WriteByte((byte)(value ? 1 : 0));
        }

static public void SaveToICO(Drawing drawing, List<int> sizes, string filename)
        {
            int headerLen = 6 + sizes.Count * 16;
            using (var icoStream = new MemoryStream())
            {
                //write ICONDIR
                icoStream.WriteByte(0);
                icoStream.WriteByte(0);
                icoStream.WriteByte(1);
                icoStream.WriteByte(0);
                icoStream.WriteByte((byte)sizes.Count);
                icoStream.WriteByte(0);
                
                icoStream.Position = headerLen;
                
                for (int i =0; i< sizes.Count; i++)
                {
                    var start = icoStream.Position;
                    SaveDrawing(drawing, sizes[i], icoStream);
                    var end = icoStream.Position;
                    int pngLen = (int)(end - start);
               
                    icoStream.Position = 6 + i * 16;
                    icoStream.WriteByte((byte)sizes[i]);
                    icoStream.WriteByte((byte)sizes[i]);
                    icoStream.WriteByte(0);
                    icoStream.WriteByte(0);
                    icoStream.WriteByte(0);
                    icoStream.WriteByte(0);
                    icoStream.WriteByte(0);
                    icoStream.WriteByte(32);

                    icoStream.WriteByte((byte)(pngLen & 0xff));
                    icoStream.WriteByte((byte)((pngLen >> 8) & 0xff)); 
                    icoStream.WriteByte((byte)((pngLen >> 16) & 0xff));
                    icoStream.WriteByte((byte)(pngLen >> 24));
                   
                    icoStream.WriteByte((byte)(start & 0xff)); 
                    icoStream.WriteByte((byte)((start >> 8) & 0xff));
                    icoStream.WriteByte((byte)((start >> 16) & 0xff));
                    icoStream.WriteByte((byte)(start >> 24));
           
                    icoStream.Position=end;
                }
                using(var icoFile=File.Create(filename))
                {
                    icoFile.Write(icoStream.GetBuffer(), 0, (int)icoStream.Position);
                }
            }
        }

[MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static void writeVarLength(MemoryStream stream, int length)
    {
      uint value = (uint)length;
      var has = true;
      while (has)
      {
        byte b = (byte)(value & 0x7f);
        value = value >> 7;
        has = value != 0;
        if (has)
          b = (byte)(b | 0x80);
        stream.WriteByte(b);
      }
    }

See More Examples