The program outputs the following values for the
Date of Easter.
\smallskip
{\tt\settabs3\columns
\+\quad09 APRIL, 01950&26 MARCH, 01967&22 APRIL, 01984\cr
\+\quad25 MARCH, 01951&14 APRIL, 01968&07 APRIL, 01985\cr
\+\quad13 APRIL, 01952&06 APRIL, 01969&30 MARCH, 01986\cr
\+\quad05 APRIL, 01953&29 MARCH, 01970&19 APRIL, 01987\cr
\+\quad18 APRIL, 01954&11 APRIL, 01971&03 APRIL, 01988\cr
\+\quad10 APRIL, 01955&02 APRIL, 01972&26 MARCH, 01989\cr
\+\quad01 APRIL, 01956&22 APRIL, 01973&15 APRIL, 01990\cr
\+\quad21 APRIL, 01957&14 APRIL, 01974&31 MARCH, 01991\cr
\+\quad06 APRIL, 01958&30 MARCH, 01975&19 APRIL, 01992\cr
\+\quad29 MARCH, 01959&18 APRIL, 01976&11 APRIL, 01993\cr
\+\quad17 APRIL, 01960&10 APRIL, 01977&03 APRIL, 01994\cr
\+\quad02 APRIL, 01961&26 MARCH, 01978&16 APRIL, 01995\cr
\+\quad22 APRIL, 01962&15 APRIL, 01979&07 APRIL, 01996\cr
\+\quad14 APRIL, 01963&06 APRIL, 01980&30 MARCH, 01997\cr
\+\quad29 MARCH, 01964&19 APRIL, 01981&12 APRIL, 01998\cr
\+\quad18 APRIL, 01965&11 APRIL, 01982&04 APRIL, 01999\cr
\+\quad10 APRIL, 01966&03 APRIL, 01983&23 APRIL, 02000\cr}
\bigskip

It needs
{\tt 4829 instructions, 51 mems, 6536 oops; 143 good guesses, 10 bad}
to get this result.
As the main program runs in $1+3*51+53+5\oops=212\oops$ and the
\mb{POP} in the subroutine consumes 153\oops\ the code to
compute the Easter Sunday requires $51\mems+6171\oops$ in total
or~$1\mem+121\oops$ per call.

The program uses some tricks. For example, the variable~$G$ is
not calculated to the value given in the first step of the algorithm
but as $G-1$ in line~105.
So the register is called~\mmm gm1 for ``$G$ minus~1.'' The missing
constant is combined with other constants in places where $G$ is
used.

A more complex trick appears in lines 116--120 for the
computation of~$Z$ in step~E3. The formula
$\lfloor(8C+5)/25\rfloor-5$ can be ``simplified'' as $y_h$ and~$y_m$
are known with $C-1=100y_h+y_m$:
$\lfloor(800y_h + 8y_m +13)/25\rfloor-5 = 32y_h +\lfloor(8y_m+13)/25\rfloor-5$.
And then the trick described in the comments can be used as $y_m<100$.

Another trick is used to compute modulo~7 in step~E7
(lines 145--156). Usually the program follows the hint
given in the answer of the exercise to use \mb{FREM} to get a
remainder. In this case a different method can be used as 7 is small.
It is based on the relation $8\equiv1\pmod7$. A digit-sum rule can be
applied to the number looked at as octal digits. With a look-up in a
register for the last round the routine is 2\oops\ faster than the \mb{FREM} method. It
doesn't implement a solution for all numbers but the range is so large
that the years stated in the entry conditions can be handled.
\bigskip

Can the program be changed to run faster?  First the initialization
of \mm rM in line~96 can be moved to the main program. The
entry conditions must then state to set this special register.
This saves 1\oop\ per call to the subroutine and needs only 1\oop\ more
in the main program.

A second idea is to use a look-up table for the computation
of~$Z$ in step~E3. A table with 100~values for
$\lfloor(8*i+13)/25\rfloor-5+43$ can be created and the
program lines 116--120 can be replaced by 
\mb{E3Z LDB acc,table,ym; 8ADDU zp43,yh,acc}.
This trades  1\mem\ by~3\oops.
(See program 1-3-2--32-luz.mms.)
\bigskip

The most radical change would be to require that the input $y$ is given
as a string of ASCII digits:

\let\author\authorH \let\source\sourceH \let\date\dateF \let\pgmname\pgmnameH
\leavevmode\lnocnt=0 \begingroup\getmmixtype=4
!\dots\lnocnt=2
yascii    GREG      0                   ! Year $y$ as ASCII string
!\dots\lnocnt=47
        !\gts Entry conditions: the year is stored in global register \mb{yascii} as ASCII digits
!\dots\lnocnt=50
        !\gts Changed special registers: 
y         GREG      0                   ! Year $y$ in binary
yh        GREG      0                   ! $y_h = \lfloor y/10000\rfloor$
ym        GREG      0                   ! $y_m = \lfloor (y-10^5y_h)/100\rfloor$
yasc      GREG      0                   ! $y$ as ASCII digits
_lfmask   GREG      #0f0f0f0f0f
_format   GREG      #2c2000000000000a
Easter    AND       t,yascii,_lfmask    ! Extract the digits.
          MOR       yh,t,16
          MOR       acc,t,8
          MOR       ext,t,4
          4ADDU     acc,acc,acc
          2ADDU     ym,acc,ext          ! $\mm ym = \mm ym = 10*\mmm ymh + \mmm yml$.
          4ADDU     acc,yh,yh           ! Compute the century number minus 1 as $100*\mm yh + \mm ym$.
          4ADDU     acc,acc,acc
c         GREG      0                   ! Century Number
E2a       4ADDU     c,acc,ym            ! \step E2. Century. $\m c\gets C-1 = \lfloor y/100\rfloor$.
          MOR       ext,t,2             ! Two digits remain for conversion.
          4ADDU     acc,c,c
          2ADDU     acc,acc,ext
          MOR       ext,t,1
          4ADDU     acc,acc,acc
          2ADDU     y,acc,ext           ! \m y is the binary code of the year $y$.
          SL        yasc,yascii,8
          OR        yasc,yasc,_format   ! Generate the output format.
! to \pgmline{106\/} are deleted\lnocnt=106
E2b       ADD       c,c,1               ! \step E2. Century. $\m c\gets C-1 +1$.
! to \pgmline{110\/} are deleted; continue with lines \pgmline{111--120\/} and insert \stopnumbering
          SL        yh,yh,2             ! \lnocnt=120 \startnumbering
          8ADDU     zp43,yh,acc         ! $\mb{zp43} \gets Z + 43$.
! to \pgmline{205\/} are not changed; the main program is replaced by\stopnumbering
_byear    GREG      #3031393530         ! 1950 as ASCII string
_eyear    GREG      #3032303030         ! 2000 as ASCII string
_incr     GREG      #c6c6c6c6c7
_amask    GREG      #3030303030
Main      SET       yascii,_byear       ! Init \mb{yascii}.
          JMP       2F
1H        ADD       acc,yascii,_incr    ! Increment \mb{yascii}.
          AND       ext,acc,_amask
          SR        ext,ext,3
          SUBU      ext,acc,ext
          AND       ext,ext,_lfmask
          OR        yascii,ext,_amask
2H        PUSHJ     $0,Easter
          CMP       t,yascii,_eyear     ! Compare to end value.
          PBNZ      t,1B
          TRAP      0,Halt,0            ! \eop
!\endprogram
\endgroup

This program (see 1-3-2--32-yasc.mms) outputs the result with the profile:
{\tt 3957 instructions, 51 mems, 5205 oops; 143 good guesses, 10 bad}.
The main program requires more operations. A single call
to the subroutine needs $1\mem + 87\oops$ without the \mb{POP}.
But this program is probably not accepted as a valid implementation
of Algorithm~E.
