```	My work load lightened considerably, so I went back to the problem of
coding the RSA algorithm, and I finished it.  Thanks to Tad Bochan for
his algorithm simplifying the work with powers! Also, Markus and Roland
I'm pasting in the code, below, since, as a nuby, I recognize that I am
probably writing it all "wrong". It is written in an obvious "C" style
so if someone could take the time to point out the correct Ruby styling,
I'd appreciate it!
Barry

include Math   # FOR SQRT

# PRINTS ASCII OF ARRAY, CURRENTLY BACKWARDS AND 8 CHARACTERS SPECIFICALLY
def convert_to_text( num )
ar = Array.new
while num > 0 do
last_two = num % 100
ar.push( last_two )
num /= 100
end
ar.reverse!   # SINCE AR.PUSH MAKES THE LAST ONE FIRST
character = Array.new   # HOLD THE SINGLE CHARACTER FOR PACK("C")
for num in 0..(ar.length - 1 ) do   # PRINT EACH CHARACTER
character[ 0 ] = ar[ num ]
print( character.pack("c") )
end
puts
end

# USE ONLY THE VALUES FROM THE ARRAY OF MODDED SQUARES
#  THAT MATCH THE "SET" BITS OF THE BASE.  CALLED FROM FIND_BASE_BITS
def find_mod_powers( bit_array, power_array, mod_num )
len = bit_array.length
prod_bit_powers = 1
for num in 0..(bit_array.length - 1) do
prod_bit_powers = ( prod_bit_powers * power_array[ bit_array[ num ] ]
) % mod_num
end
return prod_bit_powers
end

# FIND AN ARRAY TO HOLD THE "SET" BITS OF THE BASE-2 REPRESENTATION OF
THE "BASE" NUMBER
#  AND AN ARRAY TO HOLD THE SEQUENTIAL MODDED SQUARES OF THE BASE
#  CALLED TWICE FROM MAIN CODE: ONCE FOR DECRYPTION AND ONCE FOR ENCRYPTION
def find_base_bits( base, mod_num, power )
bit_pos = 0   # INIT BIT POSITION OF POWERS OF 2
bit_array = Array.new   # HOLD BIT POSITIONS OF EXPONENT
power_array = Array.new   # HOLD MODDED POWERS OF EXPONENT
modded_base = base % mod_num
while power >= 1 do    # WHILE SOME BITS ARE LEFT TO SHIFT
power_array.push( modded_base )
p = power % 2
if ( p == 1 ) then   # IF THE LEAST SIGNIFICANT BIT IS 1
bit_array.push( bit_pos )   # SAVE BIT POSITIONS
end
modded_base = ( modded_base * modded_base ) % mod_num
power >>= 1   # SHIFT RIGHT TO CHECK NEXT BIT
bit_pos += 1   # NEXT BIT POSITION
end

find_mod_powers( bit_array, power_array, mod_num )
end

# CALLED FROM MAIN CODE TO FIND THE SMALLEST DIVISOR OF A COMPOSITE
#  AND AN ASSOCIATED DIVISOR, BOTH OF WHICH ARE RETURNED.
#  IF A PRIME IS RETURNED
#  YOU MUST SEND ANOTHER MULTIPLE OF de TO THIS FUNCTION.
#  THESE FACTORS WILL BE THE POWERS OF THE BASE ASCII TEXT NUMBER
#  FOR ENCRYPTION AND DECRYPTION
def find_factors( composite )
finish = sqrt( composite )	# LARGEST DIVISOR TO CHECK
finish = finish.to_i

prime = true
divisor = 2
while divisor <= finish		# ONLY CHECK DIVISORS UP TO SQRT
if composite % divisor == 0
prime = false
print( "One factor: " ); puts divisor
print( "Second factor: " ); puts composite / divisor
break		# QUIT WHILE-LOOP IF COMPOSITE
end

divisor += 1
end

if prime == true
print( 'Prime: ' ); puts composite
end

return [ divisor, composite / divisor ]
end

# THE TEXT, TO BE ENCRYPTED AND SENT ALONG WITH THE PUBLIC KEY
#  LIMITED TO 8 CHAR, ALL WITH ASCII VALUES BELOW 100
s = "GO SKINS"
asc_of_text = 0
s.each_byte do |a|   #TAKING EACH CHAR AS A 2-DIGIT NUM AND CREATING A
print( a ); print( ' ' )     # LARGE NUM WITH EACH PAIR OF DIGITS
# BEING THE ASCII
asc_of_text *= 100          # OF THE STRING, LEFT-MOST 2 DIGITS BEING
#THE FIRST LETTER
asc_of_text += a
end
puts

# 2 PRIMES CHOSEN TO BE LARGE ENOUGH
# TO BE USED AS mod FOR THE 8-CHAR TEXT
prime_1 = 100000007
prime_2 = 100000969
mod_num = prime_1 * prime_2

# FINDING d AND e SUCH THAT (de-1) IS DIVISIBLE BY
# (SOME_PRIME - 1)(ANOTHER_PRIME - 1)
de = ( prime_1 - 1 ) * ( prime_2 - 1 ) + 1
factor_pair = find_factors( de )
e = factor_pair[ 0 ]
d = factor_pair[ 1 ]

encryp = find_base_bits( asc_of_text, mod_num, e )
print("encryp: " ); puts encryp

decryp =find_base_bits( encryp, mod_num, d )
print("decryp: " ); puts decryp
convert_to_text( decryp )

```