csvorbis.CodeBook.decodev_add C# (CSharp) Method

        internal int decodev_add(float[]a, int offset, csBuffer b,int n)
        {
            int i,j,k,entry;
            int t;

            if(dim>8)
            {
                for(i=0;i<n;)
                {
                    entry = decode(b);
                    if(entry==-1)return(-1);
                    t=entry*dim;
                    for(j=0;j<dim;)
                    {
                        a[offset+(i++)]+=valuelist[t+(j++)];
                    }
                }
            }
            else
            {
                for(i=0;i<n;)
                {
                    entry=decode(b);
                    if(entry==-1)return(-1);
                    t=entry*dim;
                    j=0;
                    for(k=0; k < dim; k++)
                    {
                        a[offset+(i++)]+=valuelist[t+(j++)];
                    }
                }
            }
            return(0);
        }

        internal int _01inverse(Block vb, Object vl, float[][] fin, int ch, int decodepart)
        {
            int          i, j, k, l, s;
            LookResidue0 look = (LookResidue0 )vl;
            InfoResidue0 info = look.info;

            // move all this setup out later
            int samples_per_partition = info.grouping;
            int partitions_per_word   = look.phrasebook.dim;
            int n = info.end - info.begin;

            int partvals  = n / samples_per_partition;
            int partwords = (partvals + partitions_per_word - 1) / partitions_per_word;

            if (partword.Length < ch)
            {
                partword = new int[ch][][];
                for (j = 0; j < ch; j++)
                {
                    partword[j] = new int[partwords][];
                }
            }
            else
            {
                for (j = 0; j < ch; j++)
                {
                    if (partword[j] == null || partword[j].Length < partwords)
                    {
                        partword[j] = new int[partwords][];
                    }
                }
            }

            for (s = 0; s < look.stages; s++)
            {
                // each loop decodes on partition codeword containing
                // partitions_pre_word partitions
                for (i = 0, l = 0; i < partvals; l++)
                {
                    if (s == 0)
                    {
                        // fetch the partition word for each channel
                        for (j = 0; j < ch; j++)
                        {
                            int temp = look.phrasebook.decode(vb.opb);
                            partword[j][l] = look.decodemap[temp];
                        }
                    }

                    // now we decode residual values for the partitions
                    for (k = 0; k < partitions_per_word && i < partvals; k++, i++)
                    {
                        for (j = 0; j < ch; j++)
                        {
                            int offset = info.begin + i * samples_per_partition;
                            if ((info.secondstages[partword[j][l][k]] & (1 << s)) != 0)
                            {
                                CodeBook stagebook = look.fullbooks[look.partbooks[partword[j][l][k]][s]];
                                if (stagebook != null)
                                {
                                    if (decodepart == 0)
                                    {
                                        stagebook.decodevs_add(fin[j], offset, vb.opb, samples_per_partition);
                                    }
                                    else if (decodepart == 1)
                                    {
                                        stagebook.decodev_add(fin[j], offset, vb.opb, samples_per_partition);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(0);
        }