SevenZip.Compression.RangeCoder.Decoder.ReleaseStream C# (CSharp) Method

        public void ReleaseStream()
        {
            // Stream.ReleaseStream();
            Stream = null;
        }

        public void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress)
        {
            Init(inStream, outStream);
            Base.State state = default(Base.State);
            state.Init();
            uint  num  = 0u;
            uint  num2 = 0u;
            uint  num3 = 0u;
            uint  num4 = 0u;
            ulong num5 = 0uL;

            if (num5 < (ulong)outSize)
            {
                if (m_IsMatchDecoders[state.Index << 4].Decode(m_RangeDecoder) != 0)
                {
                    throw new DataErrorException();
                }

                state.UpdateChar();
                byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0u, 0);
                m_OutWindow.PutByte(b);
                num5++;
            }

            while (num5 < (ulong)outSize)
            {
                uint num6 = (uint)((int)num5 & (int)m_PosStateMask);
                if (m_IsMatchDecoders[(state.Index << 4) + num6].Decode(m_RangeDecoder) == 0)
                {
                    byte @byte = m_OutWindow.GetByte(0u);
                    byte b2    = state.IsCharState()
                        ? m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)num5, @byte)
                        : m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder, (uint)num5, @byte,
                                                               m_OutWindow.GetByte(num));
                    m_OutWindow.PutByte(b2);
                    state.UpdateChar();
                    num5++;
                    continue;
                }

                uint num8;
                if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
                {
                    if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
                    {
                        if (m_IsRep0LongDecoders[(state.Index << 4) + num6].Decode(m_RangeDecoder) == 0)
                        {
                            state.UpdateShortRep();
                            m_OutWindow.PutByte(m_OutWindow.GetByte(num));
                            num5++;
                            continue;
                        }
                    }
                    else
                    {
                        uint num7;
                        if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
                        {
                            num7 = num2;
                        }
                        else
                        {
                            if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
                            {
                                num7 = num3;
                            }
                            else
                            {
                                num7 = num4;
                                num4 = num3;
                            }

                            num3 = num2;
                        }

                        num2 = num;
                        num  = num7;
                    }

                    num8 = m_RepLenDecoder.Decode(m_RangeDecoder, num6) + 2;
                    state.UpdateRep();
                }
                else
                {
                    num4 = num3;
                    num3 = num2;
                    num2 = num;
                    num8 = 2 + m_LenDecoder.Decode(m_RangeDecoder, num6);
                    state.UpdateMatch();
                    uint num9 = m_PosSlotDecoder[Base.GetLenToPosState(num8)].Decode(m_RangeDecoder);
                    if (num9 >= 4)
                    {
                        int num10 = (int)((num9 >> 1) - 1);
                        num = (2 | (num9 & 1)) << num10;
                        if (num9 < 14)
                        {
                            num += BitTreeDecoder.ReverseDecode(m_PosDecoders, num - num9 - 1, m_RangeDecoder, num10);
                        }
                        else
                        {
                            num += m_RangeDecoder.DecodeDirectBits(num10 - 4) << 4;
                            num += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
                        }
                    }
                    else
                    {
                        num = num9;
                    }
                }

                if (num >= m_OutWindow.TrainSize + num5 || num >= m_DictionarySizeCheck)
                {
                    if (num == uint.MaxValue)
                    {
                        break;
                    }

                    throw new DataErrorException();
                }

                m_OutWindow.CopyBlock(num, num8);
                num5 += num8;
            }

            m_OutWindow.Flush();
            m_OutWindow.ReleaseStream();
            m_RangeDecoder.ReleaseStream();
        }