}
        MaxAmpId --;

        for (i=1; i <=2*MlqSteps; i++)
        {
            for (j=k; j < SubFrLen; j +=Sgrid)
            {
                WrkBlk[j] = ErrBlk[j];
                OccPos[j] = (FLOAT)0.0;
            }
            Temp.MampId = MaxAmpId - MlqSteps + i;

            MaxAmp = FcbkGainTable[Temp.MampId];

            if (WrkBlk[Temp.Ploc[0]] >= (FLOAT)0.0)
                Temp.Pamp[0] = MaxAmp;
            else
                Temp.Pamp[0] = -MaxAmp;

            OccPos[Temp.Ploc[0]] = (FLOAT)1.0;

            for (j=1; j < Np; j++)
            {
                Acc1 = (FLOAT)-32768.0;

                for (l=k; l < SubFrLen; l +=Sgrid)
                {
                    if (OccPos[l] != (FLOAT)0.0)
                        continue;

                    Acc0 = WrkBlk[l] - Temp.Pamp[j-1]*
                                        ImrCorr[abs(l-Temp.Ploc[j-1])];
                    WrkBlk[l] = Acc0;

                    Acc0 = (FLOAT) fabs(Acc0);
                    if (Acc0 > Acc1)
                    {
                        Acc1 = Acc0;
                        Temp.Ploc[j] = l;
                    }
                }

                if (WrkBlk[Temp.Ploc[j]] >= (FLOAT)0.0)
                    Temp.Pamp[j] = MaxAmp;
                else
                    Temp.Pamp[j] = -MaxAmp;

                OccPos[Temp.Ploc[j]] = (FLOAT)1.0;
            }

            /* Compute error vector */

            for (j=0; j < SubFrLen; j++)
                OccPos[j] = (FLOAT)0.0;

            for (j=0; j < Np; j++)
                OccPos[Temp.Ploc[j]] = Temp.Pamp[j];

            for (l=SubFrLen-1; l >= 0; l--)
            {
                Acc0 = (FLOAT)0.0;
                for (j=0; j <= l; j++)
                    Acc0 += OccPos[j]*Imr[l-j];
                OccPos[l] = Acc0;
            }

            /* Evaluate error */

            Acc2 = ((FLOAT)2.0)*DotProd(Tv,OccPos,SubFrLen)
                   - DotProd(OccPos,OccPos,SubFrLen);

            if (Acc2 > (*Best).MaxErr)
            {
                (*Best).MaxErr = Acc2;
                (*Best).GridId = Temp.GridId;
                (*Best).MampId = Temp.MampId;
                (*Best).UseTrn = Temp.UseTrn;
                for (j = 0; j < Np; j++)
                {
                    (*Best).Pamp[j] = Temp.Pamp[j];
                    (*Best).Ploc[j] = Temp.Ploc[j];
                }
            }
        }
    }
    return;
}

/*
**
** Function:        Fcbk_Pack()
**
** Description:     Encoding of the pulse positions and gains for the high
**                  rate case.
**                  Combinatorial encoding is used to transmit the optimal
**                  combination of pulse locations.
**
** Links to text:   Section 2.15
**
** Arguments:
**
**  FLOAT  *Dpnt    Excitation vector
**  SFSDEF *Sfs     Encoded parameters of the excitation model
**  BESTDEF *Best   Parameters of the best excitation model
**  int    Np       Number of pulses (6 for even subframes; 5 for odd subframes)
**
** Outputs:
**
**  SFSDEF *Sfs     Encoded parameters of the excitation model
**
** Return value:    None
**
*/
void  Fcbk_Pack(FLOAT *Dpnt, SFSDEF *Sfs, BESTDEF *Best, int Np)
{
    int i,j;

    /* Code the amplitudes and positions */

    j = MaxPulseNum - Np;

    (*Sfs).Pamp = 0;
    (*Sfs).Ppos = 0;

    for (i=0; i < SubFrLen/Sgrid; i++)
    {
        if (Dpnt[(*Best).GridId + Sgrid*i] == 0)
            (*Sfs).Ppos = (*Sfs).Ppos + CombinatorialTable[j][i];
        else
        {
            (*Sfs).Pamp = (*Sfs).Pamp << 1;
            if (Dpnt[(*Best).GridId + Sgrid*i] < 0)
                (*Sfs).Pamp++;
            j++;

            /* Check for end  */

            if (j == MaxPulseNum)
                break;
        }
    }

    (*Sfs).Mamp = (*Best).MampId;
    (*Sfs).Grid = (*Best).GridId;
    (*Sfs).Tran = (*Best).UseTrn;
    return;
}


/*
**
** Function:        Fcbk_Unpk()
**
** Description:     Decoding of the fixed codebook excitation for both rates.
**                  Gains, pulse positions, grid position (odd or even), signs
**                  are decoded and used to reconstruct the excitation.
**
** Links to text:   Section 2.17 & 3.5
**
** Arguments:
**
**  FLOAT  *Tv      Decoded excitation vector
**  SFSDEF Sfs      Encoded parameters of the excitation (for one subframe)
**  int    Olp      Closed loop adaptive pitch lag
**  int    Sfc      Subframe index
**
** Outputs:
**
**  FLOAT  *Tv      Decoded excitation vector
**
** Return value:    None
**
*/
void  Fcbk_Unpk(FLOAT *Tv, SFSDEF Sfs, int Olp, int Sfc)
{
    int    i,j,Np;
    FLOAT  Tv_tmp[SubFrLen+4];
    FLOAT  acelp_gain,gain_T0;
    int    acelp_sign, acelp_shift, acelp_pos;
    int    offset, ipos, T0_acelp;
    Word32 Acc0;

    switch(WrkRate)
    {
        case Rate63:
        {
            Np = Nb_puls[Sfc];

            for (i=0; i < SubFrLen; i++)
                Tv[i] = (FLOAT)0.0;

            if (Sfs.Ppos >= MaxPosTable[Sfc])
                return;

            /*  Decode the amplitudes and positions */

            j = MaxPulseNum - Np;
            Acc0 = Sfs.Ppos;

            for (i = 0; i < SubFrLen/Sgrid; i++)
            {
                Acc0 -= CombinatorialTable[j][i];

                if (Acc0 < (Word32) 0)
                {
                    Acc0 += CombinatorialTable[j][i];
                    j++;

                    if ((Sfs.Pamp & (1 << (MaxPulseNum-j))) != 0)
                        Tv[Sfs.Grid + Sgrid*i] = -FcbkGainTable[Sfs.Mamp];
                    else
                        Tv[Sfs.Grid + Sgrid*i] =  FcbkGainTable[Sfs.Mamp];

                    if (j == MaxPulseNum)
                        break;
                }
            }

            if (Sfs.Tran == 1)
                Gen_Trn(Tv, Tv, Olp);
            break;
        }

        case Rate53:
        {
            for (i = 0; i < SubFrLen+4; i++)
                Tv_tmp[i] = (FLOAT)0.0;

            acelp_gain = FcbkGainTable[Sfs.Mamp];
            acelp_shift = Sfs.Grid;
            acelp_sign = Sfs.Pamp;
            acelp_pos = (int)Sfs.Ppos;

            offset  = 0;
            for (i=0; i<4; i++)
            {
                ipos = (acelp_pos & 7);
                ipos = (ipos << 3) + acelp_shift + offset;

                if ((acelp_sign & 1)== 1)
                    Tv_tmp[ipos] = acelp_gain;
                else
                    Tv_tmp[ipos] = -acelp_gain;

                offset += 2;
                acelp_pos = acelp_pos >> 3;
                acelp_sign = acelp_sign >> 1;
            }
            for (i = 0; i < SubFrLen; i++)
                Tv[i] = Tv_tmp[i];

            T0_acelp = search_T0( (Olp-1+Sfs.AcLg), Sfs.AcGn, &gain_T0);
            if (T0_acelp < SubFrLen-2)
            {
                for (i = T0_acelp; i < SubFrLen; i++)
                    Tv[i] += Tv[i-T0_acelp]*gain_T0;
            }
            break;
        }
    }
    return;
}

/*
**
** Function:        ACELP_LBC_code()
**
** Description:     Find Algebraic codebook for low bit rate LBC encoder
**
** Links to text:   Section 2.16
**
** Arguments:
**
**   FLOAT  X[]              Target vector.     (in Q0)
**   FLOAT  h[]              Impulse response.  (in Q12)
**   int    T0               Pitch period.
**   FLOAT  code[]           Innovative vector.        (in Q12)
**   int    gain             Innovative vector gain.   (in Q0)
**   int    sign             Signs of the 4 pulses.
**   int    shift            Shift of the innovative vector
**   FLOAT  gain_T0          Gain for pitch synchronous fiter
**
** Inputs :
**
**   FLOAT  X[]              Target vector.     (in Q0)
**   FLOAT  h[]              Impulse response.  (in Q12)
**   int    T0               Pitch period.
**   FLOAT  gain_T0          Gain for pitch synchronous fiter
**
** Outputs:
**
**   FLOAT  code[]           Innovative vector.        (in Q12)
**   int    gain             Innovative vector gain.   (in Q0)
**   int    sign             Signs of the 4 pulses.
**   int    shift            Shift of the innovative vector.
**
** Return value:
**
**   int    index            Innovative codebook index
**
*/
int ACELP_LBC_code(FLOAT X[], FLOAT h[], int T0, FLOAT code[],
    int *ind_gain, int *shift, int *sign, FLOAT gain_T0)
{
    int i, index;
    FLOAT gain_q;
    FLOAT Dn[SubFrLen2], tmp_code[SubFrLen2];
    FLOAT rr[DIM_RR];

    /*  Include fixed-gain pitch contribution into impulse resp. h[] */

    if (T0 < SubFrLen-2)
        for (i = T0; i < SubFrLen; i++)
            h[i] += gain_T0*h[i-T0];

    /*  Compute correlations of h[] needed for the codebook search */

    Cor_h(h, rr);

    /*  Compute correlation of target vector with impulse response. */

    Cor_h_X(h, X, Dn);

    /*  Find codebook index */

    index = D4i64_LBC(Dn, rr, h, tmp_code, rr, shift, sign);

    /*  Compute innovation vector gain. */
    /*  Include fixed-gain pitch contribution into code[]. */

    *ind_gain = G_code(X, rr, &gain_q);

    for (i=0; i < SubFrLen; i++)
        code[i] = tmp_code[i]*gain_q;

    if (T0 < SubFrLen-2)
        for (i=T0; i < SubFrLen; i++)
            code[i] += code[i-T0]*gain_T0;

    return index;
}


/*
**
** Function:        Cor_h()
**
** Description:     Compute correlations of h[] needed for the codebook search.
**
** Links to text:   Section 2.16
**
** Arguments:
**
**  FLOAT  h[]              Impulse response.
**  FLOAT  rr[]             Correlations.
**
**  Outputs:
**
**  FLOAT  rr[]             Correlations.
**
**  Return value :          None
*/
void Cor_h(FLOAT *H, FLOAT *rr)
{

    /*   Compute  correlations of h[]  needed for the codebook search. */
    /*     h[]              :Impulse response. */
    /*     rr[]             :Correlations. */

    FLOAT *rri0i0, *rri1i1, *rri2i2, *rri3i3;
    FLOAT *rri0i1, *rri0i2, *rri0i3;
    FLOAT *rri1i2, *rri1i3, *rri2i3;

    FLOAT *p0, *p1, *p2, *p3;
    FLOAT cor, *h2;
    int   i, k, m, t;
    FLOAT h[SubFrLen2];

    for (i=0; i<SubFrLen; i++)
        h[i+4] = H[i];

    for (i=0; i<4; i++)
        h[i] = (FLOAT)0.0;

    /*  Init pointers */

    rri0i0 = rr;
    rri1i1 = rri0i0 + NB_POS;
    rri2i2 = rri1i1 + NB_POS;
    rri3i3 = rri2i2 + NB_POS;

    rri0i1 = rri3i3 + NB_POS;
    rri0i2 = rri0i1 + MSIZE;
    rri0i3 = rri0i2 + MSIZE;
    rri1i2 = rri0i3 + MSIZE;
    rri1i3 = rri1i2 + MSIZE;
    rri2i3 = rri1i3 + MSIZE;

    /*  Compute rri0i0[], rri1i1[], rri2i2[] and rri3i3[] */

    cor = (FLOAT)0.0;
    m = 0;
    for (i=NB_POS-1; i>=0; i--)
    {
        cor += h[m+0]*h[m+0] + h[m+1]*h[m+1];   rri3i3[i] = cor;
        cor += h[m+2]*h[m+2] + h[m+3]*h[m+3];   rri2i2[i] = cor;
        cor += h[m+4]*h[m+4] + h[m+5]*h[m+5];   rri1i1[i] = cor;
        cor += h[m+6]*h[m+6] + h[m+7]*h[m+7];   rri0i0[i] = cor;

        m += 8;
    }

    /*  Compute elements of: rri0i1[], rri0i3[], rri1i2[] and rri2i3[] */

    h2 = h+2;
    p3 = rri2i3 + MSIZE-1;
    p2 = rri1i2 + MSIZE-1;
    p1 = rri0i1 + MSIZE-1;
    p0 = rri0i3 + MSIZE-2;

    for (k=0; k<NB_POS; k++)
    {
        cor = (FLOAT)0.0;
        m = 0;
        t = 0;

        for (i=k+1; i<NB_POS; i++)
        {
            cor += h[m+0]*h2[m+0] + h[m+1]*h2[m+1];   p3[t] = cor;
            cor += h[m+2]*h2[m+2] + h[m+3]*h2[m+3];   p2[t] = cor;
            cor += h[m+4]*h2[m+4] + h[m+5]*h2[m+5];   p1[t] = cor;
            cor += h[m+6]*h2[m+6] + h[m+7]*h2[m+7];   p0[t] = cor;

            t -= (NB_POS+1);
            m += 8;
        }
        cor += h[m+0]*h2[m+0] + h[m+1]*h2[m+1];   p3[t] = cor;
        cor += h[m+2]*h2[m+2] + h[m+3]*h2[m+3];   p2[t] = cor;
        cor += h[m+4]*h2[m+4] + h[m+5]*h2[m+5];   p1[t] = cor;

        h2 += STEP;
        p3 -= NB_POS;
        p2 -= NB_POS;
        p1 -= NB_POS;
        p0 -= 1;
    }


    /*  Compute elements of: rri0i2[], rri1i3[]  */

    h2 = h+4;
    p3 = rri1i3 + MSIZE-1;
    p2 = rri0i2 + MSIZE-1;
    p1 = rri1i3 + MSIZE-2;
    p0 = rri0i2 + MSIZE-2;

    for (k=0; k<NB_POS; k++)
    {
        cor = (FLOAT)0.0;
        m = 0;
        t = 0;

        for (i=k+1; i<NB_POS; i++)
        {
            cor += h[m+0]*h2[m+0] + h[m+1]*h2[m+1];   p3[t] = cor;
            cor += h[m+2]*h2[m+2] + h[m+3]*h2[m+3];   p2[t] = cor;
            cor += h[m+4]*h2[m+4] + h[m+5]*h2[m+5];   p1[t] = cor;
            cor += h[m+6]*h2[m+6] + h[m+7]*h2[m+7];   p0[t] = cor;

            t -= (NB_POS+1);
            m += 8;
        }
        cor += h[m+0]*h2[m+0] + h[m+1]*h2[m+1];   p3[t] = cor;
        cor += h[m+2]*h2[m+2] + h[m+3]*h2[m+3];   p2[t] = cor;

        h2 += STEP;
        p3 -= NB_POS;
        p2 -= NB_POS;
        p1 -= 1;
        p0 -= 1;
    }

    /*  Compute elements of: rri0i1[], rri0i3[], rri1i2[] and rri2i3[] */

    h2 = h+6;
    p3 = rri0i3 + MSIZE-1;
    p2 = rri2i3 + MSIZE-2;
    p1 = rri1i2 + MSIZE-2;
    p0 = rri0i1 + MSIZE-2;

    for (k=0; k<NB_POS; k++)
    {
        cor = (FLOAT)0.0;
        m = 0;
        t = 0;