System.Buffer.BlockCopy(System.Array, int, System.Array, int, int)

public override int Read(byte[] buffer, int offset, int count)
		{
			ValidateBuffer(buffer, offset, count);

			if (!m_slice.HasValue) StreamIsClosed();

			Contract.Ensures(m_position >= 0 && m_position <= m_slice.Count);

			int remaining = Math.Min(m_slice.Count - m_position, count);
			if (remaining <= 0) return 0;

			int pos = m_position;
			int start = m_slice.Offset + pos;

			if (remaining <= 8)
			{ // too small, copy it ourselves
				int n = remaining;
				while (n-- > 0)
				{
					buffer[offset + n] = m_slice.Array[start + n];
				}
			}
			else
			{ // large enough
				Buffer.BlockCopy(m_slice.Array, start, buffer, offset, remaining);
			}

			m_position += remaining;
			Contract.Ensures(m_position >= 0 && m_position <= m_slice.Count);
			return remaining;
		}

void PackUint32(uint value, byte[] buf, ref int offset)
		{
			Buffer.BlockCopy(BitConverter.GetBytes(value), 0, buf, offset, 4);
			offset = offset + 4;
		}

internal static void Copy(byte[] src, int srcOffset, byte[] dst, int dstOffset, int count)
        {
            if (count > CopyThreshold)
            {
                Buffer.BlockCopy(src, srcOffset, dst, dstOffset, count);
            }
            else
            {
                int stop = srcOffset + count;
                for (int i = srcOffset; i < stop; i++)
                {
                    dst[dstOffset++] = src[i];
                }
            }
        }

public void ParseMessage(byte[] message)
    {
        byte[] size = new byte[sizeof(int)];
        Buffer.BlockCopy(message, 0, size, 0, sizeof(int));
        byte[] data = new byte[BitConverter.ToInt32(size, 0)];
        Buffer.BlockCopy(message, sizeof(int) + 1, data, 0, data.Length);
        switch (message[sizeof(int)]) // Add cases to this switch for all different types of message the client can receive.
        {
            case (byte)NetworkingFlags.Flags.DEBUG_MESSAGE:
                OnDebugMessage(data);
                break;
            default:
                Debug.LogWarning("WARNING: Unknown byte flag " + message[sizeof(int)] + " .");
                break;
        }
    }

public static byte[] Encrypt(byte[] In, int offset, int len, byte[] key)
        {
            var temp = new byte[In.Length];
            Buffer.BlockCopy(In, 0, temp, 0, In.Length);
            var random = new Random();
            var num = (len + 10) % 8;
            if (num != 0)
            {
                num = 8 - num;
            }

            var array = new byte[len + num + 10];
            array[0] = (byte) ((random.Next() & 248) | num);
            for (var i = 1; i < num + 3; i++)
            {
                array[i] = (byte) (random.Next() & 255);
            }

            Array.Copy(temp, 0, array, num + 3, len);
            for (var j = num + 3 + len; j < array.Length; j++)
            {
                array[j] = 0;
            }

            var array2 = new byte[len + num + 10];
            for (var k = 0; k < array2.Length; k += 8)
            {
                Code(array, 0, k, array2, 0, k, key);
            }

            return array2;
        }

public Guid Create(SequentialGuidType guidType)
    {
        lock (_lock)
        {
            var randomBytes = new byte[10];
            _rng.GetBytes(randomBytes);

            var timestamp = DateTime.UtcNow.Ticks / 10000L;
            var timestampBytes = BitConverter.GetBytes(timestamp);

            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(timestampBytes);
            }

            var guidBytes = new byte[16];

            switch (guidType)
            {
                case SequentialGuidType.Sequentialreplacedtring:
                case SequentialGuidType.SequentialAsBinary:
                    Buffer.BlockCopy(timestampBytes, 2, guidBytes, 0, 6);
                    Buffer.BlockCopy(randomBytes, 0, guidBytes, 6, 10);

                    // If formatting as a string, we have to reverse the order
                    // of the Data1 and Data2 blocks on little-endian systems.
                    if (guidType == SequentialGuidType.Sequentialreplacedtring && BitConverter.IsLittleEndian)
                    {
                        Array.Reverse(guidBytes, 0, 4);
                        Array.Reverse(guidBytes, 4, 2);
                    }
                    break;

                case SequentialGuidType.SequentialAtEnd:
                    Buffer.BlockCopy(randomBytes, 0, guidBytes, 0, 10);
                    Buffer.BlockCopy(timestampBytes, 2, guidBytes, 10, 6);
                    break;
            }

            return new Guid(guidBytes);
        }
    }

void PackULong(ulong u, byte[] buf, ref int offset)
    {
        Buffer.BlockCopy(BitConverter.GetBytes(u), 0, buf, offset, sizeof(ulong));
        offset += sizeof(ulong);
    }

public int Read(byte[] bytes, int offset, int count)
        {
            if (bytes is null)
            {
                throw new ArgumentNullException(nameof(bytes));
            }
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(count));
            }
            VerifyNotDisposed();

            if (count == 0)
            {
                return 0;
            }

            if ((readOffset + count) <= readLength)
            {
                Buffer.BlockCopy(buffer, readOffset, bytes, offset, count);
                readOffset += count;

                return count;
            }
            else
            {
                // Ensure that any bytes at the end of the current buffer are included.
                int bytesUnread = readLength - readOffset;

                if (bytesUnread > 0)
                {
                    Buffer.BlockCopy(buffer, readOffset, bytes, offset, bytesUnread);
                }

                // Invalidate the existing buffer.
                readOffset = 0;
                readLength = 0;

                int totalBytesRead = bytesUnread;

                totalBytesRead += stream.Read(bytes, offset + bytesUnread, count - bytesUnread);

                return totalBytesRead;
            }
        }

public void CreateReadyToSendPacket(byte[] buffer, out int size)
        {
            uint payloadChecksum = 0u;

            int offset = PacketHeader.HeaderSize;

            if (Data != null && Data.Length > 0)
            {
                var body = Data.GetBuffer();
                Buffer.BlockCopy(body, 0, buffer, offset, (int)Data.Length);
                offset += (int)Data.Length;

                payloadChecksum += Hash32.Calculate(body, (int)Data.Length);
            }

            foreach (ServerPacketFragment fragment in Fragments)
                payloadChecksum += fragment.PackAndReturnHash32(buffer, ref offset);

            size = offset;

            Header.Size = (ushort)(size - PacketHeader.HeaderSize);

            var headerChecksum = Header.CalculateHash32();
            finalChecksum = headerChecksum + payloadChecksum;
            Header.Checksum = headerChecksum + (payloadChecksum ^ issacXor);
            Header.Pack(buffer);
        }

public int Read(byte[] bytes, int offset, int count)
        {
            if (bytes == null)
            {
                throw new ArgumentNullException(nameof(bytes));
            }
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(count));
            }
            VerifyNotDisposed();

            if (count == 0)
            {
                return 0;
            }

            if ((readOffset + count) <= readLength)
            {
                Buffer.BlockCopy(buffer, readOffset, bytes, offset, count);
                readOffset += count;

                return count;
            }
            else
            {
                // Ensure that any bytes at the end of the current buffer are included.
                int bytesUnread = readLength - readOffset;

                if (bytesUnread > 0)
                {
                    Buffer.BlockCopy(buffer, readOffset, bytes, offset, bytesUnread);
                }

                // Invalidate the existing buffer.
                readOffset = 0;
                readLength = 0;

                int totalBytesRead = bytesUnread;

                totalBytesRead += stream.Read(bytes, offset + bytesUnread, count - bytesUnread);

                return totalBytesRead;
            }
        }

private byte[] ReceiveBytes(int countByte)
        {
            //if (!Loger.IsServer) Loger.Log("Client ReceiveBytes " + countByte.ToString() + ", " + Client.ReceiveBufferSize);
            //результат
            byte[] msg = new byte[countByte];
            //сколько уже считано
            int offset = 0;
            //буфер результата
            byte[] receiveBuffer = new byte[Client.ReceiveBufferSize];
            //кол-во считано байт последний раз
            int numberOfBytesRead = 0;
            //длина передаваемого сообщения (принимается в первых 4 байтах (константа Int32Length))
            int lenghtAllMessageByte = countByte;
            var timeOut = DateTime.UtcNow.AddMilliseconds(SilenceTime);

            while (lenghtAllMessageByte > 0)
            {
                int maxCountRead = receiveBuffer.Length;
                if (maxCountRead > lenghtAllMessageByte) maxCountRead = lenghtAllMessageByte;


                //numberOfBytesRead = ClientStream.Read(receiveBuffer, 0, maxCountRead);

                var receiveId = Interlocked.Increment(ref ReceiveId);
                ClientStream.BeginRead(receiveBuffer, 0, maxCountRead, ReceiveBytescallback, receiveId);

                while (!ReceiveReady.ContainsKey(receiveId)
                    && timeOut > DateTime.UtcNow)
                    Thread.Sleep(1);

                lock (ReceiveReady)
                {
                    if (ReceiveReady.ContainsKey(receiveId))
                    {
                        var objRes = ReceiveReady[receiveId];
                        if (objRes is Exception) throw (Exception)objRes;
                        numberOfBytesRead = (int)ReceiveReady[receiveId];
                        ReceiveReady.Remove(receiveId);
                    }
                    else
                        throw new ConnectSilenceTimeOutException();
                }

                if (!Client.Client.Connected)
                {
                    throw new ConnectNotConnectedException();
                }


                if (numberOfBytesRead == 0)
                {
                    if (timeOut < DateTime.UtcNow)
                        throw new ConnectSilenceTimeOutException();
                    Thread.Sleep(1);
                }
                else
                {
                    timeOut = DateTime.UtcNow.AddMilliseconds(SilenceTime);
                    Buffer.BlockCopy(receiveBuffer, 0, msg, offset, numberOfBytesRead);
                    offset += numberOfBytesRead;
                    lenghtAllMessageByte -= numberOfBytesRead;
                }
            };

            return msg;
        }

public override int Read(byte[] buffer, int offset, int count)
        {
#if CHECK_ARGS
            if (buffer == null)
                throw new ArgumentNullException("buffer");
            if (offset < 0 || count < 0 || buffer.Length - count < offset)
                throw new ArgumentOutOfRangeException();

            if (input == null)
                throw new InvalidOperationException();
#endif
            int nRead, nToRead = count;

            var decBuf = decodeBuffer;

            //the stringy gotos are obnoxious, but their purpose is to
            //make it *blindingly* obvious how the state machine transitions
            //back and forth as it reads - remember, we can yield out of
            //this routine in several places, and we must be able to re-enter
            //and pick up where we left off!

#if LOCAL_SHADOW
			var phase = this.phase;
			var inBufPos = this.inBufPos;
			var inBufEnd = this.inBufEnd;
#endif
            switch (phase)
            {
                case DecodePhase.ReadToken:
                    goto readToken;

                case DecodePhase.ReadExLiteralLength:
                    goto readExLiteralLength;

                case DecodePhase.CopyLiteral:
                    goto copyLiteral;

                case DecodePhase.ReadOffset:
                    goto readOffset;

                case DecodePhase.ReadExMatchLength:
                    goto readExMatchLength;

                case DecodePhase.CopyMatch:
                    goto copyMatch;
            }

            readToken:
            int tok;
            if (inBufPos < inBufEnd)
            {
                tok = decBuf[inBufPos++];
            }
            else
            {
#if LOCAL_SHADOW
				this.inBufPos = inBufPos;
#endif

                tok = ReadByteCore();
#if LOCAL_SHADOW
				inBufPos = this.inBufPos;
				inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
                if (tok == -1)
                    goto finish;
#endif
            }

            litLen = tok >> 4;
            matLen = (tok & 0xF) + 4;

            switch (litLen)
            {
                case 0:
                    phase = DecodePhase.ReadOffset;
                    goto readOffset;

                case 0xF:
                    phase = DecodePhase.ReadExLiteralLength;
                    goto readExLiteralLength;

                default:
                    phase = DecodePhase.CopyLiteral;
                    goto copyLiteral;
            }

            readExLiteralLength:
            int exLitLen;
            if (inBufPos < inBufEnd)
            {
                exLitLen = decBuf[inBufPos++];
            }
            else
            {
#if LOCAL_SHADOW
				this.inBufPos = inBufPos;
#endif
                exLitLen = ReadByteCore();
#if LOCAL_SHADOW
				inBufPos = this.inBufPos;
				inBufEnd = this.inBufEnd;
#endif

#if CHECK_EOF
                if (exLitLen == -1)
                    goto finish;
#endif
            }

            litLen += exLitLen;
            if (exLitLen == 255)
                goto readExLiteralLength;

            phase = DecodePhase.CopyLiteral;
            goto copyLiteral;

            copyLiteral:
            int nReadLit = litLen < nToRead ? litLen : nToRead;
            if (nReadLit != 0)
            {
                if (inBufPos + nReadLit <= inBufEnd)
                {
                    int ofs = offset;

                    for (int c = nReadLit; c-- != 0;)
                        buffer[ofs++] = decBuf[inBufPos++];

                    nRead = nReadLit;
                }
                else
                {
#if LOCAL_SHADOW
					this.inBufPos = inBufPos;
#endif
                    nRead = ReadCore(buffer, offset, nReadLit);
#if LOCAL_SHADOW
					inBufPos = this.inBufPos;
					inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
                    if (nRead == 0)
                        goto finish;
#endif
                }

                offset += nRead;
                nToRead -= nRead;

                litLen -= nRead;

                if (litLen != 0)
                    goto copyLiteral;
            }

            if (nToRead == 0)
                goto finish;

            phase = DecodePhase.ReadOffset;
            goto readOffset;

            readOffset:
            if (inBufPos + 1 < inBufEnd)
            {
                matDst = (decBuf[inBufPos + 1] << 8) | decBuf[inBufPos];
                inBufPos += 2;
            }
            else
            {
#if LOCAL_SHADOW
				this.inBufPos = inBufPos;
#endif
                matDst = ReadOffsetCore();
#if LOCAL_SHADOW
				inBufPos = this.inBufPos;
				inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
                if (matDst == -1)
                    goto finish;
#endif
            }

            if (matLen == 15 + 4)
            {
                phase = DecodePhase.ReadExMatchLength;
                goto readExMatchLength;
            }
            else
            {
                phase = DecodePhase.CopyMatch;
                goto copyMatch;
            }

            readExMatchLength:
            int exMatLen;
            if (inBufPos < inBufEnd)
            {
                exMatLen = decBuf[inBufPos++];
            }
            else
            {
#if LOCAL_SHADOW
				this.inBufPos = inBufPos;
#endif
                exMatLen = ReadByteCore();
#if LOCAL_SHADOW
				inBufPos = this.inBufPos;
				inBufEnd = this.inBufEnd;
#endif
#if CHECK_EOF
                if (exMatLen == -1)
                    goto finish;
#endif
            }

            matLen += exMatLen;
            if (exMatLen == 255)
                goto readExMatchLength;

            phase = DecodePhase.CopyMatch;
            goto copyMatch;

            copyMatch:
            int nCpyMat = matLen < nToRead ? matLen : nToRead;
            if (nCpyMat != 0)
            {
                nRead = count - nToRead;

                int bufDst = matDst - nRead;
                if (bufDst > 0)
                {
                    //offset is fairly far back, we need to pull from the buffer

                    int bufSrc = decodeBufferPos - bufDst;
                    if (bufSrc < 0)
                        bufSrc += DecBufLen;
                    int bufCnt = bufDst < nCpyMat ? bufDst : nCpyMat;

                    for (int c = bufCnt; c-- != 0;)
                        buffer[offset++] = decBuf[bufSrc++ & DecBufMask];
                }
                else
                {
                    bufDst = 0;
                }

                int sOfs = offset - matDst;
                for (int i = bufDst; i < nCpyMat; i++)
                    buffer[offset++] = buffer[sOfs++];

                nToRead -= nCpyMat;
                matLen -= nCpyMat;
            }

            if (nToRead == 0)
                goto finish;

            phase = DecodePhase.ReadToken;
            goto readToken;

            finish:
            nRead = count - nToRead;

            int nToBuf = nRead < DecBufLen ? nRead : DecBufLen;
            int repPos = offset - nToBuf;

            if (nToBuf == DecBufLen)
            {
                Buffer.BlockCopy(buffer, repPos, decBuf, 0, DecBufLen);
                decodeBufferPos = 0;
            }
            else
            {
                int decPos = decodeBufferPos;

                while (nToBuf-- != 0)
                    decBuf[decPos++ & DecBufMask] = buffer[repPos++];

                decodeBufferPos = decPos & DecBufMask;
            }

#if LOCAL_SHADOW
			this.phase = phase;
			this.inBufPos = inBufPos;
#endif
            return nRead;
        }

private static byte[] GetPs3Hmac(Span<byte> data)
        {
            byte[] sha;
            using (var sha1 = SHA1.Create())
                sha = sha1.ComputeHash(data.ToArray());
            var buf = new byte[0x40];
            Buffer.BlockCopy(sha, 4, buf, 0, 8);
            Buffer.BlockCopy(sha, 4, buf, 8, 8);
            Buffer.BlockCopy(sha, 12, buf, 16, 4);
            buf[20] = sha[16];
            buf[21] = sha[1];
            buf[22] = sha[2];
            buf[23] = sha[3];
            Buffer.BlockCopy(buf, 16, buf, 24, 8);
            using (var sha1 = SHA1.Create())
                sha = sha1.ComputeHash(buf);
            return sha.replacedpan(0, 0x10).ToArray();
        }

static byte[] Vector3ToByteArray(Vector3 vector)
    {
        byte[] bytes = new byte[sizeof(float) * 3];

        Buffer.BlockCopy(BitConverter.GetBytes(vector.x), 0, bytes, 0 * sizeof(float), sizeof(float));
        Buffer.BlockCopy(BitConverter.GetBytes(vector.y), 0, bytes, 1 * sizeof(float), sizeof(float));
        Buffer.BlockCopy(BitConverter.GetBytes(vector.z), 0, bytes, 2 * sizeof(float), sizeof(float));

        return bytes;
    }

private void FillBuffer(int minBytes)
        {
            int bytesUnread = this.readLength - this.readOffset;

            if (bytesUnread > 0)
            {
                Buffer.BlockCopy(this.buffer, this.readOffset, this.buffer, 0, bytesUnread);
            }

            int numBytesToRead = this.bufferSize - bytesUnread;
            int numBytesRead = bytesUnread;
            do
            {
                int n = this.stream.Read(this.buffer, numBytesRead, numBytesToRead);

                if (n == 0)
                {
                    throw new EndOfStreamException();
                }

                numBytesRead += n;
                numBytesToRead -= n;

            } while (numBytesRead < minBytes);

            this.readOffset = 0;
            this.readLength = numBytesRead;
        }

public void processAvatarPacket(RemotePlayer remote, ref byte[] packet, ref int offset)
    {
        if (remote == null)
            return;

        remote.receivedRootPositionPrior = remote.receivedRootPosition;
        remote.receivedRootPosition.x = ReadFloat(packet, ref offset);
        remote.receivedRootPosition.y = ReadFloat(packet, ref offset);
        remote.receivedRootPosition.z = ReadFloat(packet, ref offset);

        remote.receivedRootRotationPrior = remote.receivedRootRotation;
        remote.receivedRootRotation.x = ReadFloat(packet, ref offset);
        remote.receivedRootRotation.y = ReadFloat(packet, ref offset);
        remote.receivedRootRotation.z = ReadFloat(packet, ref offset);
        remote.receivedRootRotation.w = ReadFloat(packet, ref offset);
        
        remote.RemoteAvatar.transform.position = remote.receivedRootPosition;
        remote.RemoteAvatar.transform.rotation = remote.receivedRootRotation;

        // forward the remaining data to the avatar system
        int sequence = (int)ReadUInt32(packet, ref offset);

        byte[] remainingAvatarBuffer = new byte[packet.Length - offset];
        Buffer.BlockCopy(packet, offset, remainingAvatarBuffer, 0, remainingAvatarBuffer.Length);

        IntPtr avatarPacket = Oculus.Avatar.CAPI.ovrAvatarPacket_Read((UInt32)remainingAvatarBuffer.Length, remainingAvatarBuffer);

        var ovravatarPacket = new OvrAvatarPacket { ovrNativePacket = avatarPacket };
        remote.RemoteAvatar.GetComponent<OvrAvatarRemoteDriver>().QueuePacket(sequence, ovravatarPacket);
    }

protected override void HashCore(byte[] array, int ibStart, int cbSize)
        {
            int dstOffset = ((int)(this.count[0] >> 3)) & 0x3f;
            this.count[0] += (uint)(cbSize << 3);

            if (this.count[0] < (cbSize << 3))
            {
                this.count[1]++;
            }

            this.count[1] += (uint)(cbSize >> 0x1d);
            int count = 0x40 - dstOffset;
            int index = 0;

            if (cbSize >= count)
            {
                Buffer.BlockCopy(array, ibStart, this.buffer, dstOffset, count);
                this.MD4Transform(this.state, this.buffer, 0);
                index = count;

                while ((index + 0x3f) < cbSize)
                {
                    this.MD4Transform(this.state, array, index);
                    index += 0x40;
                }

                dstOffset = 0;
            }

            Buffer.BlockCopy(array, ibStart + index, this.buffer, dstOffset, cbSize - index);
        }

void PackFloat(float value, byte[] buf, ref int offset)
		{
			Buffer.BlockCopy(BitConverter.GetBytes(value), 0, buf, offset, 4);
			offset = offset + 4;
		}

private static void SerializeFloat(Protocol16Stream output, float value, bool writeTypeCode)
        {
            output.WriteTypeCodeIfTrue(Protocol16Type.Float, writeTypeCode);
            var floatBuffer = _floatBuffer.Value;
            floatBuffer[0] = value;
            var buffer = _byteBuffer.Value;
            Buffer.BlockCopy(floatBuffer, 0, buffer, 0, sizeof(float));
            if (BitConverter.IsLittleEndian)
            {
                byte b0 = buffer[0];
                byte b1 = buffer[1];
                buffer[0] = buffer[3];
                buffer[1] = buffer[2];
                buffer[2] = b1;
                buffer[3] = b0;
            }
            output.Write(buffer, 0, sizeof(float));
        }

private void OnDataReceive(IAsyncResult result)
        {
            EndPoint clientEndPoint = null;

            try
            {
                clientEndPoint = new IPEndPoint(listeningHost, 0);
                int dataSize = Socket.EndReceiveFrom(result, ref clientEndPoint);

                IPEndPoint ipEndpoint = (IPEndPoint)clientEndPoint;

                // TO-DO: generate ban entries here based on packet rates of endPoint, IP Address, and IP Address Range

                if (packetLog.IsDebugEnabled)
                {
                    byte[] data = new byte[dataSize];
                    Buffer.BlockCopy(buffer, 0, data, 0, dataSize);

                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine($"Received Packet (Len: {data.Length}) [{ipEndpoint.Address}:{ipEndpoint.Port}=>{ListenerEndpoint.Address}:{ListenerEndpoint.Port}]");
                    sb.AppendLine(data.BuildPacketString());
                    packetLog.Debug(sb.ToString());
                }

                var packet = new ClientPacket();

                if (packet.Unpack(buffer, dataSize))
                    NetworkManager.ProcessPacket(this, packet, ipEndpoint);

                packet.ReleaseBuffer();
            }
            catch (SocketException socketException)
            {
                // If we get "Connection has been forcibly closed..." error, just eat the exception and continue on
                // This gets sent when the remote host terminates the connection (on UDP? interesting...)
                // TODO: There might be more, should keep an eye out. Logged message will help here.
                if (socketException.SocketErrorCode == SocketError.MessageSize ||
                    socketException.SocketErrorCode == SocketError.NetworkReset ||
                    socketException.SocketErrorCode == SocketError.ConnectionReset)
                {
                    log.DebugFormat("ConnectionListener.OnDataReceieve() has thrown {0}: {1} from client {2}", socketException.SocketErrorCode, socketException.Message, clientEndPoint != null ? clientEndPoint.ToString() : "Unknown");
                }
                else
                {
                    log.FatalFormat("ConnectionListener.OnDataReceieve() has thrown {0}: {1} from client {2}", socketException.SocketErrorCode, socketException.Message, clientEndPoint != null ? clientEndPoint.ToString() : "Unknown");
                    return;
                }
            }

            Listen();
        }

public void ReceiveCompleted(IAsyncResult result)
        {
            int length = socket.EndReceive(result);
            byte[] bytes = new byte[length];
            Buffer.BlockCopy(this.bytes, 0, bytes, 0, length);
            cacheList.AddRange(bytes);
            if (!receive)
            {
                receive = true;
                ReceiveHandle();
            }
            Receive();
        }

public static byte[] Decrypt(byte[] In, int offset, int len, byte[] key)
        {
            var temp = new byte[In.Length];
            Buffer.BlockCopy(In, 0, temp, 0, In.Length);
            if (len % 8 != 0 || len < 16)
            {
                return null;
            }

            var array = new byte[len];
            for (var i = 0; i < len; i += 8)
            {
                Decode(temp, offset, i, array, 0, i, key);
            }

            for (var j = 8; j < len; j++)
            {
                array[j] ^= temp[offset + j - 8];
            }

            var num = array[0] & 7;
            len = len - num - 10;
            var array2 = new byte[len];
            Array.Copy(array, num + 3, array2, 0, len);
            return array2;
        }

private static void SerializeDouble(Protocol16Stream output, double value, bool writeTypeCode)
        {
            output.WriteTypeCodeIfTrue(Protocol16Type.Double, writeTypeCode);
            var doubleBuffer = _doubleBuffer.Value;
            doubleBuffer[0] = value;
            var buffer = _byteBuffer.Value;
            Buffer.BlockCopy(doubleBuffer, 0, buffer, 0, sizeof(double));
            if (BitConverter.IsLittleEndian)
            {
                byte b0 = buffer[0];
                byte b1 = buffer[1];
                byte b2 = buffer[2];
                byte b3 = buffer[3];
                buffer[0] = buffer[7];
                buffer[1] = buffer[6];
                buffer[2] = buffer[5];
                buffer[3] = buffer[4];
                buffer[4] = b3;
                buffer[5] = b2;
                buffer[6] = b1;
                buffer[7] = b0;
            }
            output.Write(buffer, 0, sizeof(double));
        }

public static void BlockCopy(byte[] from, int fromIndex, byte[] to, int toIndex, int count)
        {
#if MF || WINRT
            Array.Copy(from, fromIndex, to, toIndex, count);
#else
            Buffer.BlockCopy(from, fromIndex, to, toIndex, count);
#endif
        }

public byte[] Concat(params byte[][] arrays)
        {
            int len = 0;

            foreach (byte[] array in arrays)
            {
                if (array == null)
                    continue;
                len += array.Length;
            }

            byte[] result = new byte[len - 1 + 1];
            int offset = 0;

            foreach (byte[] array in arrays)
            {
                if (array == null)
                    continue;
                Buffer.BlockCopy(array, 0, result, offset, array.Length);
                offset += array.Length;
            }

            return result;
        }

public static byte[] Combine(byte[] first, byte[] second)
		{
			byte[] ret = new byte[first.Length + second.Length];
			Buffer.BlockCopy(first, 0, ret, 0, first.Length);
			Buffer.BlockCopy(second, 0, ret, first.Length, second.Length);
			return ret;
		}

public uint[] UnpackBitVector (PackedBitVector pakData)
		{
			uint[] unpackedVectors = new uint[pakData.m_NumItems];
			//int bitmax = 0;//used to convert int value to float
			//for (int b = 0; b < pakData.m_BitSize; b++) { bitmax |= (1 << b); }
			
			//the lazy way
			//split data into groups of "aligned" bytes i.e. 8 packed values per group
			//I could calculate optimized group size based on BitSize, but this is the lazy way
			
			if (pakData.m_BitSize == 0)
			{
				pakData.m_BitSize = (byte)((pakData.m_Data.Length * 8) / pakData.m_NumItems);
				//don't know, don't care
			}
			int groupSize = pakData.m_BitSize; //bitSize * 8 values / 8 bits
			byte[] group = new byte[groupSize];
			int groupCount = pakData.m_NumItems / 8;

			for (int g = 0; g < groupCount; g++)
			{
				Buffer.BlockCopy(pakData.m_Data, g * groupSize, group, 0, groupSize);
				BitArray groupBits = new BitArray(group);

				for (int v = 0; v < 8; v++)
				{
					BitArray valueBits = new BitArray(new Boolean[pakData.m_BitSize]);
					for (int b = 0; b < pakData.m_BitSize; b++)
					{
						valueBits.Set(b, groupBits.Get(b + v * pakData.m_BitSize));
					}

					var valueArr = new int[1];
					valueBits.CopyTo(valueArr, 0);
					//unpackedVectors[v + g * 8] = (float)(valueArr[0] / bitmax) * pakData.m_Range + pakData.m_Start;
					//valueBits.CopyTo(unpackedVectors, v + g * 8);//doesn't work with uint[]
					unpackedVectors[v + g * 8] = (uint)valueArr[0];
				}
			}

			//m_NumItems is not necessarily a multiple of 8, so there can be one extra group with fewer values
			int endBytes = pakData.m_Data.Length - groupCount * groupSize;
			int endVal = pakData.m_NumItems - groupCount * 8;

			if (endBytes > 0)
			{
				Buffer.BlockCopy(pakData.m_Data, groupCount * groupSize, group, 0, endBytes);
				BitArray groupBits = new BitArray(group);

				for (int v = 0; v < endVal; v++)
				{
					BitArray valueBits = new BitArray(new Boolean[pakData.m_BitSize]);
					for (int b = 0; b < pakData.m_BitSize; b++)
					{
						valueBits.Set(b, groupBits.Get(b + v * pakData.m_BitSize));
					}

					var valueArr = new int[1];
					valueBits.CopyTo(valueArr, 0);
					//unpackedVectors[v + groupCount * 8] = (float)(valueArr[0] / bitmax) * pakData.m_Range + pakData.m_Start;
					//valueBits.CopyTo(unpackedVectors, v + groupCount * 8);
					unpackedVectors[v + groupCount * 8] = (uint)valueArr[0];
				}
			}


			//the hard way
			//compute bit position in m_Data for each value
			/*byte[] value = new byte[4] { 0, 0, 0, 0 };

			int byteCount = pakData.m_BitSize / 8;//bytes in single value
			int bitCount = pakData.m_BitSize % 8;

			for (int v = 0; v < pakData.m_NumItems; v++)
			{
				if ((bitCount * v) % 8 == 0) //bitstream is "aligned"
				{//does this make sense if I'm gonna compute unaligned anywhay?
					for (int b = 0; b < byteCount; b++)
					{
						value[b] = pakData.m_Data[b + v * (byteCount+1)];
					}

					if (byteCount < 4) //shouldn't it be always?
					{
						byte lastByte = pakData.m_Data[bitCount * v / 8];

						for (int b = 0; b < bitCount; b++)//no
						{
							//set bit in val[byteCount+1]
						}
					}
				}
				else
				{
					//god knows
				}

				unpackedVectors[v] = BitConverter.ToSingle(value, 0);
			}*/


			//first I split the data into byte-aligned arrays
			//too complicated to calculate group size each time
			//then no point in dividing?
			/*int groupSize = byteCount + (bitCount + 7)/8;

			int groups = pakData.m_Data.Length / groupSize;
			int valPerGr = (int)(pakData.m_NumItems / groups);
			byte[] group = new byte[groupSize];

			for (int g = 0; g < groups; g++)
			{
				Buffer.BlockCopy(pakData.m_Data, g * groupSize, group, 0, groupSize);

				for (int v = 0; v < valPerGr; v++)
				{

					unpackedVectors[v + g * valPerGr] = BitConverter.ToSingle(value, 0);
				}
			}

			//m_Data size is not necessarily a multiple of align, so there can be one extra group with fewer values
			int lastBytes = pakData.m_Data.Length % groupSize;
			int lastVal = (int)(pakData.m_NumItems - groups * valPerGr);

			if (lastBytes > 0)
			{
				Buffer.BlockCopy(pakData.m_Data, groups * groupSize, group, 0, lastBytes);

				for (int v = 0; v < lastVal; v++)
				{

					unpackedVectors[v + groups * valPerGr] = BitConverter.ToSingle(value, 0);
				}
			}*/

			return unpackedVectors;
		}

private static byte[] GetCmac(Span<byte> data, byte[] omacKey, bool truncate = true)
        {
            if (omacKey?.Length != 0x10)
                throw new ArgumentException(nameof(omacKey));

            static byte[] AESEncrypt(byte[] key, byte[] iv, Span<byte> dataToEncrypt)
            {
                using var result = new MemoryStream();
                using var aes = Aes.Create();
                aes.Mode = CipherMode.CBC;
                aes.Padding = PaddingMode.None;
                using var cs = new CryptoStream(result, aes.CreateEncryptor(key, iv), CryptoStreamMode.Write);
                cs.Write(dataToEncrypt);
                cs.FlushFinalBlock();
                return result.ToArray();
            }

            static byte[] Rol(byte[] b)
            {
                var r = new byte[b.Length];
                byte carry = 0;
                for (var i = b.Length - 1; i >= 0; i--)
                {
                    ushort u = (ushort)(b[i] << 1);
                    r[i] = (byte)((u & 0xff) + carry);
                    carry = (byte)((u & 0xff00) >> 8);
                }
                return r;
            }

            // SubKey generation
            // step 1, AES-128 with key K is applied to an all-zero input block.
            byte[] derivedKey = AESEncrypt(omacKey, new byte[16], new byte[16]);

            // step 2, K1 is derived through the following operation:
            byte[] subKey1 = Rol(derivedKey); //If the most significant bit of L is equal to 0, K1 is the left-shift of L by 1 bit.
            if ((derivedKey[0] & 0x80) == 0x80)
                subKey1[15] ^= 0x87; // Otherwise, K1 is the exclusive-OR of const_Rb and the left-shift of L by 1 bit.

            // step 3, K2 is derived through the following operation:
            byte[] subKey2 = Rol(subKey1); // If the most significant bit of K1 is equal to 0, K2 is the left-shift of K1 by 1 bit.
            if ((subKey1[0] & 0x80) == 0x80)
                subKey2[15] ^= 0x87; // Otherwise, K2 is the exclusive-OR of const_Rb and the left-shift of K1 by 1 bit.

            // MAC computing
            byte[] buf;
            if ((data.Length != 0) && (data.Length % 16 == 0))
            {
                // If the size of the input message block is equal to a positive multiple of the block size (namely, 128 bits),
                // the last block shall be exclusive-OR'ed with K1 before processing
                buf = new byte[data.Length];
                Buffer.BlockCopy(data.ToArray(), 0, buf, 0, data.Length-16);
                for (var j = 0; j < subKey1.Length; j++)
                {
                    var idx = data.Length - 16 + j;
                    buf[idx] = (byte)(data[idx] ^ subKey1[j]);
                }
            }
            else
            {
                // Otherwise, the last block shall be padded with 10^i
                var paddingLength = 16 - data.Length % 16;
                buf = new byte[data.Length + paddingLength];
                Buffer.BlockCopy(data.ToArray(), 0, buf, 0, data.Length);
                buf[data.Length] = 0x80;
                // and exclusive-OR'ed with K2
                for (int j = 0; j < subKey2.Length; j++)
                    buf[buf.Length - 16 + j] ^= subKey2[j];
            }

            // The result of the previous process will be the input of the last encryption.
            byte[] encResult = AESEncrypt(omacKey, new byte[16], buf);
            if (truncate)
                return encResult.replacedpan(encResult.Length - 16, 16).ToArray();
            else
                return encResult.replacedpan(encResult.Length - 0x14, 0x14).ToArray();
        }

public static bool ExecuteCommand(ref SmiObject message)
        {
            byte[] bytes = StructToByteArray(message);
            byte[] buffer = new byte[BufferLength];
            Buffer.BlockCopy(bytes, 0, buffer, 0, bytes.Length);
            bool result = ExecuteCommand(ref buffer);
            message = ByteArrayToStruct(buffer);

            return result;
        }

private void FillBuffer(int minBytes)
        {
            int bytesUnread = readLength - readOffset;

            if (bytesUnread > 0)
            {
                Buffer.BlockCopy(buffer, readOffset, buffer, 0, bytesUnread);
            }

            int numBytesToRead = bufferSize - bytesUnread;
            int numBytesRead = bytesUnread;
            do
            {
                int n = stream.Read(buffer, numBytesRead, numBytesToRead);

                if (n == 0)
                {
                    throw new EndOfStreamException();
                }

                numBytesRead += n;
                numBytesToRead -= n;

            } while (numBytesRead < minBytes);

            readOffset = 0;
            readLength = numBytesRead;
        }

static byte[] FlagMessage(byte[] data, NetworkingFlags.Flags flag)
    {
        byte[] flaggedData = new byte[data.Length + sizeof(int) + 1];

        Buffer.BlockCopy(BitConverter.GetBytes(data.Length), 0, flaggedData, 0, sizeof(int));
        flaggedData[sizeof(int)] = (byte)flag;
        Buffer.BlockCopy(data, 0, flaggedData, sizeof(int) + 1, data.Length);

        return flaggedData;
    }

private static byte[] GetSha1Hmac(Span<byte> data, Span<byte> key)
        {
            if (key.Length != 0x40)
                throw new ArgumentException(nameof(key));

            var ipad = new byte[0x40];
            var tmp = new byte[0x40 + 0x14]; // opad + hash(ipad + message)

            for (var i = 0; i < ipad.Length; i++)
            {
                tmp[i] = (byte)(key[i] ^ 0x5c); // opad
                ipad[i] = (byte)(key[i] ^ 0x36);
            }

            using (var sha1 = SHA1.Create())
            {
                sha1.TransformBlock(ipad.ToArray(), 0, ipad.Length, null, 0);
                sha1.TransformFinalBlock(data.ToArray(), 0, data.Length);
                Buffer.BlockCopy(sha1.Hash, 0, tmp, 0x40, 0x14);
            }
            using (var sha1 = SHA1.Create())
                return sha1.ComputeHash(tmp);
        }

public void ParseMessage(byte[] message, int connectionId)
    {
        byte[] size = new byte[sizeof(int)];
        Buffer.BlockCopy(message, 0, size, 0, sizeof(int));
        byte[] data = new byte[BitConverter.ToInt32(size, 0)];
        Buffer.BlockCopy(message, sizeof(int) + 1, data, 0, data.Length);
        switch (message[sizeof(int)]) // Add cases to this switch for all different types of message the server can receive.
        {
            case (byte)NetworkingFlags.Flags.DEBUG_MESSAGE:
                OnDebugMessage(data, connectionId);
                break;
            default:
                Debug.LogWarning("WARNING: Unknown byte flag " + message[sizeof(int)] + " .");
                break;
        }
    }

private static void SerializeLong(Protocol16Stream output, long value, bool writeTypeCode)
        {
            output.WriteTypeCodeIfTrue(Protocol16Type.Long, writeTypeCode);
            var longBuffer = _longBuffer.Value;
            longBuffer[0] = value;
            var buffer = _byteBuffer.Value;
            Buffer.BlockCopy(longBuffer, 0, buffer, 0, sizeof(long));
            if (BitConverter.IsLittleEndian)
            {
                byte b0 = buffer[0];
                byte b1 = buffer[1];
                byte b2 = buffer[2];
                byte b3 = buffer[3];
                buffer[0] = buffer[7];
                buffer[1] = buffer[6];
                buffer[2] = buffer[5];
                buffer[3] = buffer[4];
                buffer[4] = b3;
                buffer[5] = b2;
                buffer[6] = b1;
                buffer[7] = b0;
            }
            output.Write(buffer, 0, sizeof(long));
        }

public void SendAvatarUpdate(ulong userID, Transform rootTransform, UInt32 sequence, byte[] avatarPacket)
    {
        const int UPDATE_DATA_LENGTH = 41;
        byte[] sendBuffer = new byte[avatarPacket.Length + UPDATE_DATA_LENGTH];

        int offset = 0;
        PackByte((byte)MessageType.Update, sendBuffer, ref offset);

        PackULong(SocialPlatformManager.MyID, sendBuffer, ref offset);

        PackFloat(rootTransform.position.x, sendBuffer, ref offset);
        // Lock to floor height
        PackFloat(0f, sendBuffer, ref offset);
        PackFloat(rootTransform.position.z, sendBuffer, ref offset);
        PackFloat(rootTransform.rotation.x, sendBuffer, ref offset);
        PackFloat(rootTransform.rotation.y, sendBuffer, ref offset);
        PackFloat(rootTransform.rotation.z, sendBuffer, ref offset);
        PackFloat(rootTransform.rotation.w, sendBuffer, ref offset);

        PackUInt32(sequence, sendBuffer, ref offset);

        Debug.replacedert(offset == UPDATE_DATA_LENGTH);

        Buffer.BlockCopy(avatarPacket, 0, sendBuffer, offset, avatarPacket.Length);
        Net.SendPacket(userID, sendBuffer, SendPolicy.Unreliable);
    }

public byte[] ReplaceBytes(byte[] src, byte[] search, byte[] repl)
        {
            byte[] dst = null;
            int index = FindBytes(src, search);
            if (index >= 0)
            {
                dst = new byte[src.Length - search.Length + repl.Length];
                // before found array
                Buffer.BlockCopy(src, 0, dst, 0, index);
                // repl copy
                Buffer.BlockCopy(repl, 0, dst, index, repl.Length);
                // rest of src array
                Buffer.BlockCopy(
                    src,
                    index + search.Length,
                    dst,
                    index + repl.Length,
                    src.Length - (index + search.Length));
            }
            return dst;
        }

void PackFloat(float f, byte[] buf, ref int offset)
    {
        Buffer.BlockCopy(BitConverter.GetBytes(f), 0, buf, offset, sizeof(float));
        offset += sizeof(float);
    }

private int ReadInternal(byte[] bytes, int offset, int count)
        {
            if (count == 0)
            {
                return 0;
            }

            if ((this.readOffset + count) <= this.readLength)
            {
                if (count <= 8)
                {
                    // Use a for loop when copying a small number of bytes.
                    for (int i = 0; i < count; i++)
                    {
                        bytes[offset + i] = this.buffer[this.readOffset + i];
                    }
                }
                else
                {
                    Buffer.BlockCopy(this.buffer, this.readOffset, bytes, offset, count);
                }
                this.readOffset += count;

                return count;
            }
            else
            {
                // Ensure that any bytes at the end of the current buffer are included.
                int bytesUnread = this.readLength - this.readOffset;

                if (bytesUnread > 0)
                {
                    Buffer.BlockCopy(this.buffer, this.readOffset, bytes, offset, bytesUnread);
                }

                // Invalidate the existing buffer.
                this.readOffset = 0;
                this.readLength = 0;

                int totalBytesRead = bytesUnread;

                totalBytesRead += this.stream.Read(bytes, offset + bytesUnread, count - bytesUnread);

                return totalBytesRead;
            }
        }

void PackUInt32(UInt32 u, byte[] buf, ref int offset)
    {
        Buffer.BlockCopy(BitConverter.GetBytes(u), 0, buf, offset, sizeof(UInt32));
        offset += sizeof(UInt32);
    }

public override void Write(byte[] buffer, int offset, int count)
        {
            while (count > 0)
            {
                int blockSize = Math.Min(inBuffer.nBytes - inPosition, count);
                Buffer.BlockCopy(buffer, offset, inBuffer.bytes, inPosition, blockSize);

                inPosition += blockSize;
                count -= blockSize;
                offset += blockSize;

                if (inPosition >= inBuffer.nBytes)
                    Encode();
            }
        }

void PackInt32(int value, byte[] buf, ref int offset)
		{
			Buffer.BlockCopy(BitConverter.GetBytes(value), 0, buf, offset, 4);
			offset = offset + 4;
		}

public override int Read(byte[] buffer, int offset, int count)
        {
            int dif = _length - _position;
            if (dif <= 0)
            {
                return 0;
            }
            if (count > dif)
            {
                count = dif;
            }
            Buffer.BlockCopy(_buffer, _position, buffer, offset, count);
            _position += count;

            return count;
        }

void PackFloat(float f, byte[] buf, ref int offset)
		{
			Buffer.BlockCopy(BitConverter.GetBytes(f), 0, buf, offset, 4);
			offset = offset + 4;
		}

internal byte[] ReadRawBytes(int size)
        {
            if (size < 0)
            {
                throw InvalidProtocolBufferException.NegativeSize();
            }

            if (totalBytesRetired + bufferPos + size > currentLimit)
            {
                // Read to the end of the stream (up to the current limit) anyway.
                SkipRawBytes(currentLimit - totalBytesRetired - bufferPos);
                // Then fail.
                throw InvalidProtocolBufferException.TruncatedMessage();
            }

            if (size <= bufferSize - bufferPos)
            {
                // We have all the bytes we need already.
                byte[] bytes = new byte[size];
                ByteArray.Copy(buffer, bufferPos, bytes, 0, size);
                bufferPos += size;
                return bytes;
            }
            else if (size < buffer.Length)
            {
                // Reading more bytes than are in the buffer, but not an excessive number
                // of bytes.  We can safely allocate the resulting array ahead of time.

                // First copy what we have.
                byte[] bytes = new byte[size];
                int pos = bufferSize - bufferPos;
                ByteArray.Copy(buffer, bufferPos, bytes, 0, pos);
                bufferPos = bufferSize;

                // We want to use RefillBuffer() and then copy from the buffer into our
                // byte array rather than reading directly into our byte array because
                // the input may be unbuffered.
                RefillBuffer(true);

                while (size - pos > bufferSize)
                {
                    Buffer.BlockCopy(buffer, 0, bytes, pos, bufferSize);
                    pos += bufferSize;
                    bufferPos = bufferSize;
                    RefillBuffer(true);
                }

                ByteArray.Copy(buffer, 0, bytes, pos, size - pos);
                bufferPos = size - pos;

                return bytes;
            }
            else
            {
                // The size is very large.  For security reasons, we can't allocate the
                // entire byte array yet.  The size comes directly from the input, so a
                // maliciously-crafted message could provide a bogus very large size in
                // order to trick the app into allocating a lot of memory.  We avoid this
                // by allocating and reading only a small chunk at a time, so that the
                // malicious message must actually *be* extremely large to cause
                // problems.  Meanwhile, we limit the allowed size of a message elsewhere.

                // Remember the buffer markers since we'll have to copy the bytes out of
                // it later.
                int originalBufferPos = bufferPos;
                int originalBufferSize = bufferSize;

                // Mark the current buffer consumed.
                totalBytesRetired += bufferSize;
                bufferPos = 0;
                bufferSize = 0;

                // Read all the rest of the bytes we need.
                int sizeLeft = size - (originalBufferSize - originalBufferPos);
                List<byte[]> chunks = new List<byte[]>();

                while (sizeLeft > 0)
                {
                    byte[] chunk = new byte[Math.Min(sizeLeft, buffer.Length)];
                    int pos = 0;
                    while (pos < chunk.Length)
                    {
                        int n = (input == null) ? -1 : input.Read(chunk, pos, chunk.Length - pos);
                        if (n <= 0)
                        {
                            throw InvalidProtocolBufferException.TruncatedMessage();
                        }
                        totalBytesRetired += n;
                        pos += n;
                    }
                    sizeLeft -= chunk.Length;
                    chunks.Add(chunk);
                }

                // OK, got everything.  Now concatenate it all into one buffer.
                byte[] bytes = new byte[size];

                // Start by copying the leftover bytes from this.buffer.
                int newPos = originalBufferSize - originalBufferPos;
                ByteArray.Copy(buffer, originalBufferPos, bytes, 0, newPos);

                // And now all the chunks.
                foreach (byte[] chunk in chunks)
                {
                    Buffer.BlockCopy(chunk, 0, bytes, newPos, chunk.Length);
                    newPos += chunk.Length;
                }

                // Done.
                return bytes;
            }
        }

public byte[] ReadBytes(int count)
        {
            if (count < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(count));
            }
            VerifyNotDisposed();

            if (count == 0)
            {
                return EmptyArray<byte>.Value;
            }

            byte[] bytes = new byte[count];

            if ((readOffset + count) <= readLength)
            {
                Buffer.BlockCopy(buffer, readOffset, bytes, 0, count);
                readOffset += count;
            }
            else
            {
                // Ensure that any bytes at the end of the current buffer are included.
                int bytesUnread = readLength - readOffset;

                if (bytesUnread > 0)
                {
                    Buffer.BlockCopy(buffer, readOffset, bytes, 0, bytesUnread);
                }

                int numBytesToRead = count - bytesUnread;
                int numBytesRead = bytesUnread;
                do
                {
                    int n = stream.Read(bytes, numBytesRead, numBytesToRead);

                    if (n == 0)
                    {
                        throw new EndOfStreamException();
                    }

                    numBytesRead += n;
                    numBytesToRead -= n;

                } while (numBytesToRead > 0);

                // Invalidate the existing buffer.
                readOffset = 0;
                readLength = 0;
            }

            return bytes;
        }

private void HandleSegmentedPayload(int startSequenceNumber, int totalLength, int fragmentLength, int fragmentOffset, byte[] source, ref int offset)
        {
            SegmentedPackage segmentedPackage = GetSegmentedPackage(startSequenceNumber, totalLength);

            Buffer.BlockCopy(source, offset, segmentedPackage.TotalPayload, fragmentOffset, fragmentLength);
            offset += fragmentLength;
            segmentedPackage.BytesWritten += fragmentLength;

            if (segmentedPackage.BytesWritten >= segmentedPackage.TotalLength)
            {
                _pendingSegments.Remove(startSequenceNumber);
                HandleFinishedSegmentedPackage(segmentedPackage.TotalPayload);
            }
        }

public override void Write(byte[] buffer, int offset, int count)
        {
            int sum = _position + count;
            ExpandIfNeeded(sum);
            if (sum > _length)
            {
                _length = sum;
            }
            Buffer.BlockCopy(buffer, offset, _buffer, _position, count);
            _position = sum;
        }

public static AvifWriterItem CreateFromExif(uint itemId, byte[] exif)
            {
                // The AVIF format includes the offset to the start of the TIFF header
                // before the EXIF data.
                // The EXIF blob that this plug-in creates will always have the TIFF header
                // at offset 0, so we only need to copy the EXIF data to a new byte array.

                byte[] contentBytes = new byte[sizeof(uint) + exif.Length];
                Buffer.BlockCopy(exif, 0, contentBytes, 4, exif.Length);

                ExifItemInfoEntry exifItemInfo = new ExifItemInfoEntry(itemId);

                return new AvifWriterItem(itemId, "Exif", contentBytes, exifItemInfo);
            }

public override int Read( byte[] buffer, int offset, int count)
        {
            if (Position == inputStream.Length)
                return 0;

            var positionInSector = Position % sectorSize;
            var resultCount = 0;
            if (positionInSector > 0)
            {
                var len = (int)Math.Min(Math.Min(count, sectorSize - positionInSector), inputStream.Position - Position);
                md5.TransformBlock(bufferedSector, (int)positionInSector, len, buffer, offset);
                sha1.TransformBlock(bufferedSector, (int)positionInSector, len, buffer, offset);
                sha256.TransformBlock(bufferedSector, (int)positionInSector, len, buffer, offset);
                offset += len;
                count -= len;
                resultCount += len;
                Position += len;
                if (Position % sectorSize == 0)
                    SectorPosition++;
            }
            if (Position == inputStream.Length)
                return resultCount;

            int readCount;
            do
            {
                readCount = inputStream.ReadExact(tmpSector, 0, sectorSize);
                if (readCount < sectorSize)
                    Array.Clear(tmpSector, readCount, sectorSize - readCount);
                var decryptedSector = tmpSector;
                if (IsEncrypted(SectorPosition))
                {
                    WasEncrypted = true;
                    if (readCount % 16 != 0)
                    {
                        Log.Debug($"Block has only {(readCount % 16) * 8} bits of data, reading raw sector...");
                        discStream.Seek(SectorPosition * sectorSize, SeekOrigin.Begin);
                        var newTmpSector = new byte[sectorSize];
                        discStream.ReadExact(newTmpSector, 0, sectorSize);
                        if (!newTmpSector.Take(readCount).SequenceEqual(tmpSector.Take(readCount)))
                            Log.Warn($"Filesystem data and raw data do not match for sector 0x{SectorPosition:x8}");
                        tmpSector = newTmpSector;
                    }
                    using var aesTransform = aes.CreateDecryptor(decryptionKey, GetSectorIV(SectorPosition));
                    decryptedSector = aesTransform.TransformFinalBlock(tmpSector, 0, sectorSize);
                }
                else
                    WasUnprotected = true;
                if (count >= readCount)
                {
                    md5.TransformBlock(decryptedSector, 0, readCount, buffer, offset);
                    sha1.TransformBlock(decryptedSector, 0, readCount, buffer, offset);
                    sha256.TransformBlock(decryptedSector, 0, readCount, buffer, offset);
                    offset += readCount;
                    count -= readCount;
                    resultCount += readCount;
                    Position += readCount;
                    SectorPosition++;
                }
                else // partial sector read
                {
                    Buffer.BlockCopy(decryptedSector, 0, bufferedSector, 0, sectorSize);
                    md5.TransformBlock(decryptedSector, 0, count, buffer, offset);
                    sha1.TransformBlock(decryptedSector, 0, count, buffer, offset);
                    sha256.TransformBlock(decryptedSector, 0, count, buffer, offset);
                    offset += count;
                    count = 0;
                    resultCount += count;
                    Position += count;
                }
            } while (count > 0 && readCount == sectorSize);
            return resultCount;
        }

private static float[] Convert24BitByteArrayToAudioClipData(byte[] source, int headerOffset, int dataSize)
		{
			int wavSize = BitConverter.ToInt32(source, headerOffset);
			headerOffset += sizeof(int);
			Debug.replacedertFormat(wavSize > 0 && wavSize == dataSize, "Failed to get valid 24-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);

			int x = 3; // block size = 3
			int convertedSize = wavSize / x;

			int maxValue = Int32.MaxValue;

			float[] data = new float[convertedSize];

			byte[] block = new byte[sizeof(int)]; // using a 4 byte block for copying 3 bytes, then copy bytes with 1 offset

			int offset = 0;
			int i = 0;
			while (i < convertedSize)
			{
				offset = i * x + headerOffset;
				Buffer.BlockCopy(source, offset, block, 1, x);
				data[i] = (float)BitConverter.ToInt32(block, 0) / maxValue;
				++i;
			}

			Debug.replacedertFormat(data.Length == convertedSize, "AudioClip .wav data is wrong size: {0} == {1}", data.Length, convertedSize);

			return data;
		}