Lucas Lehmer C implementation up to M31 without BIGINT - c

Question

I started learning C yesterday and I've literally just learned the basic data types (char, int, float), while loops, operators and printing.
Before I learn anything more, I wanted to set myself a mathematical challenge as the above should be enough to do elementary arithmetic. These are the constraints I'm working within - I'm well aware there are other ways to do the problem, like I could create an array to store all of the values of the Lucas Lehmer sequence, or I could use BIGINT etc. But I'm trying to use just what I've learned so far.
It just so happens that the largest possible INT value in C is 2^31-1, which is also a Mersenne Prime, M31. So I'd like to write a function which tests all candidate Mersennes up to M31.
This was my initial stab at it:
#include <stdio.h>
#include <stdbool.h>
int main() {
int p = 3;
while (p < 32) {
int e = 0;
int Mp = 1;
while (e < p) {
Mp *= 2;
++e;
}
Mp -= 1;
printf("Testing p=%d: %d\n", p, Mp);
int i = 0;
int Si = 4;
while (i < (p - 2))
{
Si = (Si * Si - 2) % Mp;
++i;
}
if (Si == 0) {
printf("2^%d is prime: %d\n", p, Mp);
}
++p;
++p;
}
return 0;
}
This worked up to p = 13, at which point we get a problem in the generation of the Si numbers, in particular the squaring, which wraps round beyond the limit for a signed INT.
In order to handle the squaring in a way that doesn't involve getting a number bigger than 2^31-1 I turned multiplication into repeated addition:
int main() {
int p = 3;
while (p < 32) {
int e = 0;
int Mp = 1;
while (e < p) {
Mp *= 2;
++e;
}
Mp -= 1;
int i = 0;
int Si = 4;
while (i < (p - 2))
{
int newSi;
newSi = 0;
int multiplications = 0;
while (multiplications < Si) {
newSi = (newSi + Si) % Mp;
++multiplications;
}
Si = newSi - 2;
++i;
}
if (Si == 0) {
printf("2^%d is prime: %d\n", p, Mp);
}
++p;
++p;
}
return 0;
}
But this had a huge effect on the time complexity of the function. It also only detected up to 2^19-1 as prime. Switching all values to unsigned instead of int makes the algorithm work up to 2^31 - 1, as below, but I'm trying to avoid doing so as I'd really like to do this within the bounds of a signed integer, just to see if it's possible.
#include <stdio.h>
int main() {
unsigned p = 3;
while (p < 32) {
unsigned e = 0;
unsigned Mp = 1;
while (e < p) {
Mp *= 2;
++e;
}
Mp -= 1;
unsigned i = 0;
unsigned Si = 4;
while (i < (p - 2))
{
unsigned newSi;
newSi = 0;
unsigned multiplications = 0;
while (multiplications < Si) {
newSi = (newSi + Si) % Mp;
++multiplications;
}
Si = newSi - 2;
++i;
}
if (Si == 0) {
printf("2^%d is prime: %d\n", p, Mp);
}
++p;
++p;
}
return 0;
}
But this has had a huge effect on the time complexity of the function.
Can anyone advise if there's an efficient way to run this function with only the functionality I've learned to date? I'm very particular about this constraint on the functionality I can use - I could easily just follow the next few lessons and learn other features of C, but the challenge here is to do so using these elementary skills only. I have found other questions on StackOverflow relating to an implementation of LL testing, but none that ask about an efficient algorithm that just uses math operators, int, while and printf.