# code for strings

def lowercase(c):  # True if char c is lower-case alphabetical
    a = ord(c)  # ascii value
    if (a>=ord('a') and a<=ord('z')): return True
    else: return False
    # better to write above if else as just:
    # return (a>=ord('a') and a<=ord('z'))
    # the if-else is redundant since the return values is a boolean
##

def uppercase(c):  # True if char c is upper-case alphabetical
    a = ord(c)  # ascii value
    return (a>=ord('A') and a<=ord('Z')) # returns True or False value
##


def alphabetical(c):
    return uppercase(c) or lowercase(c)
##


def lower(s):   # return s with all lower case
    t = "" # string to be returned
    i = 0
    while i<len(s):
        if uppercase(s[i]):
            sa = ord(s[i])
            sa = sa+32    # 'A' is 65, 'a' is 97, etc.
            la = chr(sa)
            t = t + la
            # t = t+ chr(ord(s[i])+32)
        else:
            t = t + s[i]
        i += 1
    #while
    return t
## lower

def cieq(s,t):  # case insensitive equality
    return lower(s) == lower(t)
##

def reverse(s):
    t = ""
    i = 0
    while i<len(s):
        t = s[i] + t
        i += 1
    #
    return t
## reverse

### function to convert string to array
def strtoarray(s):
    A =[' '] * len(s)
    i = 0
    while i<len(s):
        A[i] = s[i]
        i += 1
    ##
    return A
##

def arrtostring(A):
    s = ""
    i = 0
    while i<len(A):
        s = s+A[i]
        i += 1
    ##
    return s
##

def asciivals(s): # return array of ascii values of string s
    a = strtoarray(s)
    i = 0
    while i<len(a):
        a[i] = ord(a[i])
        i += 1
    #
    return a
##

#### The RSA (Rivest-Shamir-Adelman) public key encription algorithm works
# as follows.  Two large prime numbers p and q are picked at random and
# multiplied together: n=p*q.  Two more numbers e and d are picked that
# have the property (e*d) % (p-1)*(q-1) == 1.  The pair (n,e) is called
# the public key and is used to encript, while the pair (n,d) is called
# the private key and is used to decrypt.  To encript a number m, calculate
# (m**e) % n, and to decrypt an encrypted number c, calculate (c**d)%n.
# This allows us to encrypt/decrypt up to n-1 different numbers.  For our
# example, p and q are kept small (47 and 59) and we will encrypt the
# ascii values of individual characters.

a = "MatthewFrank is one word"
m = asciivals(a)
print asciivals(a)  # [36,78,101,...]

def encrypt(m,n,e):  # a is array of ascii vals, n,e is encryption key
    b = []  # array to be built
    i =0
    while i<len(m):
        b.append(  m[i]**e % n  )
        i += 1
    #while
    return b
##

## p,q = 47, 59  n==p*q = 2773, e,d = 17,157
c = encrypt(m,2773,17)
print c

def decrypt(c,n,d):
    #b = []  # array to be built
    s = ""
    i =0
    while i<len(c):
        #b.append(  c[i]**d % n  )
        s = s+ chr(c[i]**d %n)
        i += 1
    #while
    return s
    
## decrypt

cd = decrypt(c,2773,157)
print "\n", cd