Periods of Reciprocals of Integers

[Macumazahn]

I'm tutoring a friend's son in math, and recently we've been practicing the long-division algorithm.
We started looking at the reciprocals of integers, which led to a discussion of their decimal representations.
Some of course "terminate" like 1/2 or 1/5. Others repeat forever, like 1/3 or 1/6.
For simplicity we considered the "terminating" decimal representations to be repeating decimals, with '0' repeating forever.
This made me wonder how to determine the period of the decimal representation of the reciprocal of an integer.
I'm sure this has been answered long ago for the general case, but I like to see for myself.
To this end I defined the "preamble" to be that part of the decimal that precedes the repeating part, and the "period" to be the length of one cycle of the repeating part.
The division algorithm shows both that every such reciprocal 1/n must eventually repeat, and that the maximum possible period is (n-1).
More to the point, the algorithm also reveals that the repetition of digits begins when a repeated remainder is first encountered.
So... I coded up a program, first for my workhorse 32Sii, then for my 41CX.
The challenge here is that the program must keep track of all the remainders it has seen, so that it can detect the first repetition.
That means a bitmap, which means that the range is limited by available memory.
That in turn means making the program as small as possible, while using as few registers as possible.
I was able to split the program into six routines, each stored in extended memory. These six routines load one another as required, using GETP.
I was able to squeeze the routines down to the point where the largest of the six requires 64 bytes. I just can't get it to 63 (which would improve range).
The silver lining in that cloud is that it means I can use a more capable version of one of the other programs ("Q"), as long as that version is no larger than 70 bytes.
Unlike the 32Sii which supports 36 bits per register, the 41CX supports only 30.
By squeezing the programs down to 70 bytes or less, I can execute SIZE 309 which (since I use two registers for other things) gives the program a maximum range of 30*(309-2)=9210.
The program actually runs through the division twice - first, to find the matching remainder, and second, to count off the preamble and period. I know it's slow, but I sacrificed time for space in order to maximize range.

The user interface is as follows:

If flag 00 is set, the program will display the decimal digits as it counts the preamble and period.
Flag 01 is set by the program when it completes the count of the preamble and begins counting the period, and cleared when the entire calculation is complete.
If flag 02 is set, the program will pause with TIME displayed, to allow a crude measure of elapsed time. Continue the program with R/S to see the actual results.

Place "P" in Alpha
XEQ GETP

Once the initial program "P" is loaded, functionality is as follows:

XEQ 01 = reset (reloads program "P")

Place positive integer argument n (1 <= n <= 9210) in stack-X
XEQ 02 = calculate preamble and period
Returns:
period-length in stack-X
preamble-length in stack-Y
n in stack-Z (also in Last-X)
matched-remainder in stack-T

If somehow we already know the matched-remainder, we can escape the 9210 limit as follows:

Place matched-remainder in stack-Y
Place n in stack-X
XEQ 03 = calculate preamble and period
Returns: the same stack of results as XEQ 02 above.

The program may be interrupted (and continued) as desired to change flag 00 or 02 settings.
However, the display of digits (SF 00) cannot be activated for the first time once the counting of the preamble has begun.
The program may be terminated at any time, and reset by XEQ 01.

If anyone could tell me how to squeeze program "R" down to 63 bytes without using an additional register or sacrificing functionality, I could extend the range to 9240...

Code:

1    LBL "P"
2    "P"
3    FIX 0
4    FC?C 01
5    GTO 00
6    FC? 02
7    GTO 08
8    TIME
9    TONE 9
10    FIX 4
11    STOP
12    FIX 0
13    RDN
14    LBL 08
15    LASTX
16    RCL 01
17    RCL 02
18    GTO 00
19    LBL 02
20    FIX 0
21    CLRG
22    1
23    ENTER↑
24    2
25    "R"
26    GETP
27    LBL 03
28    FIX 0
29    "T"
30    GETP
31    LBL 01
32    FIX 0
33    "P"
34    GETP
35    LBL 00
36    END

Code:

1    LBL "R"
2    "U"
3    LBL 10
4    STO 00
5    RDN
6    X<>Y
7    STO Z
8    MOD
9    ENTER↑
10    STO 01
11    30
12    ST/ Y
13    RDN
14    INT
15    ST+ 00
16    R↑
17    *
18    -
19    2
20    X<>Y
21    Y↑X
22    RCL IND 00
23    X<>Y
24    ST/ Y
25    X<>Y
26    INT
27    2
28    /
29    ENTER↑
30    INT
31    -
32    X≠0?
33    GETP
34    X<>Y
35    ST+ IND 00
36    R↑
37    RCL 01
38    10
39    *
40    2
41    GTO 10
42    LBL 01
43    "P"
44    GETP
45    END

Code:

1    LBL "U"
2    "T"
3    RCL 01
4    R↑
5    GETP
6    LBL 01
7    "P"
8    GETP
9    END

Code:

1    LBL "T"
2    "S"
3    FS? 00
4    "Q"
5    CLRG
6    CF 01
7    1
8    STO 00
9    GETP
10    LBL 01
11    CF 01
12    "P"
13    GETP
14    END

Code:

1    LBL "S"
2    "P"
3    LBL 11
4    X<>Y
5    MOD
6    LASTX
7    1
8    ST+ IND 00
9    RDN
10    X<> Z
11    X=Y?
12    GTO 00
13    LBL 13
14    STO T
15    CLX
16    10
17    *
18    GTO 11
19    LBL 00
20    FS? 01
21    GETP
22    SF 01
23    R↑
24    ST+ 00
25    RDN
26    GTO 13
27    LBL 01
28    CF 01
29    GETP
30    END

Code:

1    LBL "Q"
2    "P"
3    LBL 12
4    FS? 00
5    GTO 00
6    X<>Y
7    MOD
8    GTO 09
9    LBL 00
10    STO 03
11    X<>Y
12    ST/ Y
13    X<>Y
14    INT
15    PSE
16    X<>Y
17    *
18    ST- 03
19    CLX
20    RCL 03
21    LBL 09
22    LASTX
23    1
24    ST+ IND 00
25    RDN
26    X<> Z
27    X=Y?
28    GTO 00
29    LBL 14
30    STO T
31    CLX
32    10
33    *
34    GTO 12
35    LBL 00
36    FS? 01
37    GETP
38    SF 01
39    2
40    STO 00
41    RDN
42    GTO 14
43    LBL 01
44    CF 01
45    GETP
46    END