From the following code in Matlab, pass it to mathematical calculations with the word "UAM" and rectify its result with the code already provided

clc $\%$clear all variables

clear $\%$clear the screen

aux$=[22]$; $\%$auxiliary variable that helps us to consider $2$ bits of memory

$\%$Initialize counters of the $8$ cases to zero $(0|00,0|01,0|10,$ etc...$)$

cont$0\_00=0$;

cont$0\_01=0$;

cont$0\_10=0$;

cont$0\_11=0$;

cont$1\_00=0$;

cont$1\_01=0$;

cont$1\_10=0$;

cont$1\_11=0$;

$\%$Initialize counters of the $4$ cases to zero $(00,01,10,11)$

cont$00=0$;

cont$01=0$;

cont$10=0$;

cont$11=0$;

$\%$General counter to $0$

conta$=0$;

$\%$ Enter the message

str$=$input$(\text{'}$Enter the message: $\text{'})$;

aux$\_$En$=$dec$2$bin$($str$,8)$;$\%$convert the message to binary $($each character to $8-$bit binary$)$

$\%$separate bit by bit

for t$1=1$:length$($str$)$

for t$2=1$:$8$

En$($t$1,$t$2)=$bin$2$dec$($aux$\_$En$($t$1,$t$2))$;

end

end

$\%$Concatenate all the bits to have it in a vector

conte$=1$;

for k$1=1$:length$($En$($:$,1))$

for k$2=1$:$8$

P$\_$aux$($conte$)=$En$($k$1,$k$2)$;

conte$=$conte$+1$;

end

end

M$=$P$\_$aux;

for k$=1$:length$($M$)$

if k$==1\%$For the first iteration, both aux values $$equal $2,$ which is of no use to us; they must be $0$ or $1$

aux$(1,1)=2$; $\%$first aux value

aux$(1,2)=2$; $\%$second aux value

else $\%$from the second iteration onwards

aux$(1,2)=$aux$(1,1)$; $\%$We scan the values $$in memory, the second value takes the value of the first

aux$(1,1)=$M$($k$-1)$; $\%$The first value of aux takes the first value of the message

end

if k$>=3\%$From the third iteration, these are already favorable cases or events, the values $$in the memory are already different from $2$

conta$=$conta$+1$;$\%$the favorable case is counted

if M$($k$)==0\%$Cases for when the information bit is $0$

if $(($aux$(1,1)==0)$ && $($aux$(1,2)==0))\%$It asks if the memory has $00$

$\%$Increments counters

cont$0\_00=$cont$0\_00+1$;

cont$00=$cont$00+1$;

elseif $(($aux$(1,1)==0)$ && $($aux$(1,2)==1))\%$It asks if the memory has $01$

$\%$Increments counters

cont$0\_01=$cont$0\_01+1$;

cont$01=$cont$01+1$;

elseif $(($aux$(1,1)==1)$ && $($aux$(1,2)==0))\%$Asks if the memory has $10$

$\%$Increments counters

cont$0\_10=$cont$0\_10+1$;

cont$10=$cont$10+1$;

else $\%$Asks if the memory has $11$

$\%$Increments counters

cont$0\_11=$cont$0\_11+1$;

cont$11=$cont$11+1$;

end

else $\%$Same procedure, for when the information bit is $1$

if $(($aux$(1,1)==0)$ && $($aux$(1,2)==0))$

cont$1\_00=$cont$1\_00+1$;

cont$00=$cont$00+1$;

elseif $(($aux$(1,1)==0)$ && $($aux$(1,2)==1))$ cont$1\_01=$cont$1\_01+1$;

cont$01=$cont$01+1$;

elseif $(($aux$(1,1)==1)$ && $($aux$(1,2)==0))$ cont$1\_10=$cont$1\_10+1$;

cont$10=$cont$10+1$;

else cont$1\_11=$cont$1\_11+1$;

cont$11=$cont$11+1$;

end

end

end

end

Probabilities are calculated considering favorable cases among total cases

$\%($P$(0|00),$ P$(0|01),$ P$(0|10),$ etc.

P$\_0\_00=$cont$0\_00/$cont;

P$\_0\_01=$cont$0\_01/$cont;

P$\_0\_10=$cont$0\_10/$cont;

P$\_0\_11=$cont$0\_11/$cont;

P$\_1\_00=$cont$1\_00/$cont;

P$\_1\_01=$cont$1\_01/$cont;

P$\_1\_10=$cont$1\_10/$cont;

P$\_1\_11=$cont$1\_11/$cont;

Probabilities are calculated considering favorable cases among total cases

$\%($P$(00),$ P$(01),$ P$(10),$ P$(11)$ P$\_00=$cont$00/$count;

P$\_01=$cont$01/$count;

P$\_10=$cont$10/$count;

P$\_11=$cont$11/$count;

$\%$Vectors are generated with the probability calculated for the case of $0$ and $1$ Probas$\_0=[$P$\_0\_00,$ P$\_0\_01,$ P$\_0\_10,$ P$\_0\_11]$;

Probas$\_1=[$P$\_1\_00,$ P$\_1\_01,$ P$\_1\_10,$ P$\_1\_11]$;

Test$\_$states$=[$P$\_00,$ P$\_01,$ P$\_10,$ P$\_11]$;

$\%$The denominator is calculated sum$=0$;

for k$=1$:length$($Probas$\_0)$ aux$1=$Probas$\_0($k$)*$Proba$\_$states$($k$)$;

aux$2=$Test$\_1($k$)*$Test$\_$states$($k$)$;

sum$=$sum$+$aux$1+$aux$2$;

end $\%$Vectors are generated to calculate the final probabilities Probas$=[$P$\_0\_00,$ P$\_0\_01,$ P$\_0\_10,$ P$\_0\_11,$ P$\_1\_00,$ P$\_1\_01,$ P$\_1\_10,$ P$\_1\_11]$;

States$=[$P$\_00,$ P$\_01,$ P$\_10,$ P$\_11,$ P$\_00,$ P$\_01,$ P$\_10,$ P$\_11]$;

$\%$Final probabilities are calculated for k$=1$:length$($Probas$)$ P$($k$)=($Probas$($k$)*$States$($k$))/$sum;

end $\%$Entropy is calculated for k$=1$:length$($P$)$ if P$($k$)==0$ R$($k$)=0$;

else R$($k$)=-$P$($k$)*$log$2($P$($k$))$;

end end $\%$Entropy H$=$sum$($R$)$