i am trying to implement RSA in python(i am new to python) for my course, the problem i have is the code i have written does not work for numbers with more than 4 digits. any idea why this is happening? please advice

```
p =0
q=0
n=0#modules
phyPQ = 0
e = 0 #public key exponent
d = 0#private key exponent
c = ''
m = ''
def getPrimes():
global p
global q
p = long(raw_input("Enter first prime p : "))
q = long(raw_input("Enter second prime q : "))
def computeModules(prime1, prime2):
global n
n = prime1 * prime2
print "Modules is = "+ `n`
return n
def computePhyPQ(prime1, prime2):
global phyPQ
phyPQ = (prime1 -1) * (prime2 -1)
print "The phyPQ is " + `phyPQ`
def computePublickeyExponent(x):
pubKeyExponentList= []
for i in range(1, x):
if x % i != 0:
pubKeyExponentList.append(i)
print pubKeyExponentList
global e
e = long(raw_input("Pick a public key exponent from the list above : "))
def computePrivateKeyExponent(phyQP, pubKeyExpo):
flag = 1
count = 0
while flag == 1:
count = count + 1
if (count * phyQP + 1) % phyQP == 1:
result = (count * phyQP + 1) / float(pubKeyExpo)
if result % 1 == 0:
global d
d = long(result)
print 'The private key exponent exponent is:' + `d`
flag = 0
def encryptMessage(exponent, modules):
#c= m ^e mod n
global c
message= long(raw_input("Enter a value to be encrypted:"))
c = long((message ** exponent) % modules)
print'The encrypted message is :' + `c`
def decryptMessage(modules, privateKeyExpo, cryptedMessage):
#m = c^d % n
global m
m = (cryptedMessage ** privateKeyExpo) % modules
print 'message after decrypting is :' + `m`
def mainMethod():
getPrimes()
computeModules(p, q)
computePhyPQ(p, q)
computePublickeyExponent(phyPQ)
computePrivateKeyExponent(phyPQ, e)
encryptMessage(e, n)
decryptMessage(n, d, c)
mainMethod()
```

Your problem is most likely in your use of floating point arithmetic:

```
result = (count * phyQP + 1) / float(pubKeyExpo)
```

In this algorithm, it will be important to use arbitrary precision *integer* arithmetic throughout.

The three-argument version of `pow()`

will be useful in a few places in your implementation. `pow(x, y, z)`

calculates `(x ** y) mod z`

for arbitrary-precision integers.