Largest Left-Truncatable Prime in a given base

#include <bits/stdc++.h>
using namespace std;

// Function to check if a number
// is even or not
bool is_even(int n) {
    return n % 2 == 0;
}

// Function to compute base^exp mod m
int expmod(int base, int exp, int m) {
    if (exp == 0) {
        return 1;
    }
    else if (is_even(exp)) {
        return (int)pow(expmod(base, exp / 2, m), 2) % m;
    }
    else {
        return base * expmod(base, exp - 1, m) % m;
    }
}

// Function to check if a is
// a composite number || not
// using Miller-Rabin primality test
bool try_composite(int a, int d, int n, int s) {
    // ((a) ^ d) % n equal to 1
    if (expmod(a, d, n) == 1) {
        return false;
    }

    for (int i = 0; i < s; i++) {
        if (expmod(a, pow(2, i) * d, n) == n - 1) {
            return false;
        }
    }
    return true;
}

// Function to check if a number
// is prime || not using
// Miller-Rabin primality test
bool is_probable_prime(int n, int k) {
    // Base Case
    if (n == 0 || n == 1) {
        return false;
    }
    if (n == 2) {
        return true;
    }
    if (n % 2 == 0) {
        return false;
    }

    int s = 0;
    int d = n - 1;

    while (true) {
        int quotient = d / 2;
        int remainder = d % 2;
        if (remainder == 1) {
            break;
        }
        s += 1;
        d = quotient;
    }

    // Iterate given number of k times 
    for (int i = 0; i < k; i++) {
        int a = rand() % (n - 2) + 2;

        // If a is a composite number
        if (try_composite(a, d, n, s)) {
            return false;
        }
    }
    // No base tested showed
    // n as composite
    return true;
}

// Function to find the largest
// left-truncatable prime number
int largest_left_truncatable_prime(int base) {
    // Stores count of digits
    // in a number
    int radix = 0;

    // Stores left-truncatable prime
    vector<int> candidates{0};

    // Iterate over the range [0, infinity]
    while (true) {
        // Store left-truncatable prime
        // containing i digits
        vector<int> new_candidates;

        // Stores base ^ radix
        int multiplier = pow(base, radix);
        
        // Iterate over all possible 
        // value of the given base
        for (int i = 1; i < base; i++)
        {
            
            // Append the i in radix-th digit
            // in all (i - 1)-th digit 
            // left-truncatable prime
            for (auto x : candidates)
                
                
                // If a number with i digits
                // is prime
                if (is_probable_prime(
                    x + i * multiplier, 30))
                    new_candidates.push_back(
                         x + i * multiplier);
        }
                         
        // If no left-truncatable prime found
        // whose digit is radix                 
        if (new_candidates.size() == 0)
            return *max_element(candidates.begin(), candidates.end());
            
            
        // Update candidates[] to all 
        // left-truncatable prime
        // whose digit is radix 
        candidates = new_candidates;
        
        
        // Update radix
        radix += 1;
    }
}


// Driver Code
int main()
{
    int N = 3;
    int ans = largest_left_truncatable_prime(N);
    cout << ans ;
}

// This code is contributed by Phasing17.