OK, now the code.

"lndx" is the array length (last index +1) for byte array "sieve"
The pi are index values into the "sieve" array.

I can functionally perform the same code equivalently like this:

begin p8 lndx < while 0 p8 sieve c!  x1 p8 + to p8 repeat
begin p7 lndx < while 0 p7 sieve c!  x1 p7 + to p7 repeat
begin p6 lndx < while 0 p6 sieve c!  x1 p6 + to p6 repeat
begin p5 lndx < while 0 p5 sieve c!  x1 p5 + to p5 repeat
begin p4 lndx < while 0 p4 sieve c!  x1 p4 + to p4 repeat
begin p3 lndx < while 0 p3 sieve c!  x1 p3 + to p3 repeat
begin p2 lndx < while 0 p2 sieve c!  x1 p2 + to p2 repeat
begin p1 lndx < while 0 p1 sieve c!  x1 p1 + to p1 repeat

This is shorter but MUCH slower on a single core/single threaded cpu
system. HOWEVER, this code represent CONCEPTUALLY exactly what I would
want to do if I had a system which could perform each line as a
separate independent simultaneous thread, ala a parallel processor/
threaded system. (For my Ruby friend, I performed a Ruby threaded
version using this approach which, because Ruby threads ARE NOT really
simultaneous parallel processes, is slower.)

So, when p8 < lndx is true, then all the other pi are < lndx too.
But when p8 >= lndx then pi < lndx will still be true for some pi and
what I want to do is find the pi for which pi < lndx is true and then
use all those pi to do   0 pi sieve c!   one last time.
So a "jump to/goto" structure would be ideal, to enable me to not have
to check for each  pi < lndx.  Comprendes toto?

And for my Ruby friend again, in the Ruby version all I have to do
is:  while  p1 < lndx ....end  and let the array grow past the real
size I need, and then I "squeeze" it to eliminate "nils" when its time
to do final processing of the "sieve" array.

: clearsome  lndx 0 do  0 i p c!  loop ;
sets all the array elements of "0" which is not want I want.

I hope this now provides sufficient understanding of my code,