function inner_out=inner_decode(demod_input,extrin,nextstate,formerstate,fanout,number_of_states,output,sgma21,sgma22)
% this function simulates the iterative MAP demodulation of the
% inner DFH system

depth_of_trellis=size(demod_input,2);
alpha=zeros(number_of_states,depth_of_trellis);
alpha(:,1)=[0;-1e10*ones(number_of_states-1,1)];
alpha1=zeros(1,fanout);
gamma=zeros(fanout,depth_of_trellis);
max=-1e10*ones(1,depth_of_trellis-1);
beta=zeros(number_of_states,depth_of_trellis);
beta(:,depth_of_trellis)=log(1/number_of_states)*ones(number_of_states,1);
beta1=zeros(1,fanout);
lu=zeros(fanout-1,depth_of_trellis); 

% forward recursion
for i=1:depth_of_trellis-1
    for j=1:number_of_states
        for k=1:fanout
            %if(formerstate(j,1,k)~=number_of_states)
                %for h=1:fanout
                sel=demod_input(output(formerstate(j,k)+1,k)+1,i);
                neg=sum(demod_input(:,i))-sel;
                a=70-(sel/sgma21+neg/sgma22);
                    if(k~=fanout)
                        %gamma(h,i)=demod_input(output(formerstate(j,h,k)+1,k)+1,i)+extrin(k,i);
                        %else
                        %gamma(h,i)=demod_input(output(formerstate(j,h,k)+1,k)+1,i);
                        %end
                        %gamma(k,i)=demod_input(output(formerstate(j,k)+1,k)+1,i)+extrin(k,i);
                        gamma(k,i)=a+extrin(k,i);
                    else
                        %gamma(k,i)=demod_input(output(formerstate(j,k)+1,k)+1,i);
                        gamma(k,i)=a;
                    end
                    %alpha1(h)=alpha(formerstate(j,h,k)+1,i)+gamma(h,i);
                    alpha1(k)=alpha(formerstate(j,k)+1,i)+gamma(k,i);
                    if(alpha1(k)<=-80)
                        alpha1(k)=0;
                    else
                        alpha1(k)=exp(alpha1(k));
                    end
                end
                if(sum(alpha1)>1e-30)
                    alpha(j,i+1)=log(sum(alpha1));
                else
                    alpha(j,i+1)=-1e10;
                end
                if(max(i)<alpha(j,i+1))
                    max(i)=alpha(j,i+1);
                end
            end
            %end
        %end
    alpha(:,i+1)=alpha(:,i+1)-max(i);
end

% backward recursion and compute the log-likelihood ratio
for i=depth_of_trellis:-1:1
    temp=zeros(1,fanout);
    for j=1:number_of_states
        for k=1:fanout
            sel=demod_input(output(j,k)+1,i);
            neg
            if(k~=fanout)
                gamma(k,i)=demod_input(output(j,k)+1,i)+extrin(k,i);
            else
                gamma(k,i)=demod_input(output(j,k)+1,i);
            end
            beta1(k)=beta(nextstate(j,k)+1,i)+gamma(k,i);
            if(beta1(k)<=-80)
                beta1(k)=0;
            else
                beta1(k)=exp(beta1(k));
            end
            temp(k)=temp(k)+exp(alpha(j,i)+gamma(k,i)+beta(nextstate(j,k)+1,i));
        end
        if(i>1)
            if(sum(beta1)>1e-30)
                beta(j,i-1)=log(sum(beta1))-max(i-1);
            else
                beta(j,i-1)=-1e10;
            end
        end
    end
    for g=1:fanout-1
        if(temp(g)==0)
            lu(g,i)=-100;
        elseif(temp(fanout)==0)
            lu(g,i)=log(temp(g))+100;
        else
            lu(g,i)=log(temp(g)/temp(fanout));
        end
        if(lu(g,i)>80)
            lu(g,i)=80;
        elseif(lu(g,i)<-80)
            lu(g,i)=-80;
        end
        inner_out(g,i)=lu(g,i)-extrin(g,i);
        if(inner_out(g,i)>45)
            inner_out(g,i)=45;
        elseif(inner_out(g,i)<-45)
            inner_out(g,i)=-45;
        end
    end
end
%inner_out=lu-extrin;