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

        public uint DecodeDirectBits(int numTotalBits)
        {
            uint range = Range;
            uint code = Code;
            uint result = 0;
            for (int i = numTotalBits; i > 0; i--)
            {
                range >>= 1;
                /*
                result <<= 1;
                if (code >= range)
                {
                    code -= range;
                    result |= 1;
                }
                */
                uint t = (code - range) >> 31;
                code -= range & (t - 1);
                result = (result << 1) | (1 - t);

                if (range < kTopValue)
                {
                    code = (code << 8) | (byte)Stream.ReadByte();
                    range <<= 8;
                }
            }
            Range = range;
            Code = code;
            return result;
        }

        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();
        }