So, I started to calculate a SQRT approximation (the SQRT(6000) = 244 instead of 244,9489742...).

The first draft of the software was able to calculate SQRT(26) = 5, but SQRT(60000) was wrong. Together with ChatGPT we analyzed the code and we found the problem.

To compare two unsigned 16 bit numbers in a 16 bit machine without a CMP command is not easy...my first draft was this...and is wrong:

// -------------- Now check quadrat > n , quadrat == n or quadrat <= n -------

// Check if quadrat > 1000 0000 *************

daten[46] = 0x4010; // BN
daten[47] = 56;       // quadrat >= 1000 0000

// quadrat < 1000 0000 *********************

daten[48] = 0x1800; // LDAM
daten[49] = 3;     // n

daten[50] = 0x4010; // BN
daten[51] = 54;       // n >= 1000 0000

daten[52] = 0x4000; //BA
daten[53] = 60;        // Compare n and quadrat

daten[54] = 0x4000; //BA
daten[55] = 92;        // Quadrat < n

// quadrat >= 1000 0000 *****************

daten[56] = 0x1800; // LDAM
daten[57] = 3;     // n

daten[58] = 0x4010; // BN
daten[59] = 82;       // n < quadrat, else: compare

// Compare n and quadrat, n in accu

daten[60] = 0x3540; //NOT
daten[61] = 0;

daten[62] = 0x3440; //ADD
daten[63] = 0x0001;

daten[64] = 0x2800; // STAM
daten[65] = 69; // ADD for compare

daten[66] = 0x1800; // LDAM
daten[67] = 8;     // quadrat

daten[68] = 0x3440; //ADD
daten[69] = 0x0001;

daten[70] = 0x4018; // BZ
daten[71] = 76;         // quadrat == n

daten[72] = 0x4010; // BN
daten[73] = 92;       // n > quadrat

daten[74] = 0x4000; //BA
daten[75] = 82;        // quadrat > n

You see, I use BN (to check the MSB) and make a distinction between greater/smaller 8000 0000. Looks funny and is wrong.

The new compare looks that way, much, much better:

// -------------- Now check quadrat > n , quadrat == n or quadrat <= n -------

daten[46]  = 0x1800;  // LDAM n
daten[47]  = 3;     //   b bei daten[101]
daten[48]  = 0x3540;  // NOT A       ; A = ~b
daten[49]  = 0;       
daten[50]  = 0x2800;  // STAM 9      ; daten[9] = ~b
daten[51]  = 57;       
daten[52]  = 0x1800;  // LDAM a      ; A = a
daten[53]  = 8;     //   a bei daten[100]
daten[54] = 0x3440;  // ADD 1       ; A = a – b
daten[55] = 1;       
daten[56]  = 0x3440;  // ADD [n]     ; A = a + (~b)
daten[57]  = 1;       //   wird von STAM(9) mit ~b ersetzt

daten[58] = 0x4018;  // BZ → 300    ; if A==0   ⇒ a==b
daten[59] = 76;     
daten[60] = 0x4008;  // BC → 100    ; if Carry ⇒ a>b
daten[61] = 82;     
daten[62] = 0x4000;  // BA → 200    ; else      a<b
daten[63] = 92;     

The idea from ChatGPT was to use BC instead of BN...and worked.

In my C# simulation of the relay CPU (very useful) the new program works fine, so I will prepare a new video.