My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too. Or just jump to my GitHub repository.

       
#include <iostream>
       
#include <unordered_map>
       
#include <queue>
       
#include <vector>
       
 
       
// ---------- standard prime sieve from my toolbox ----------

       
 
       
// odd prime numbers are marked as "true" in a bitvector

       
std::vector<bool> sieve;
       
 
       
// return true, if x is a prime number

       
bool isPrime(unsigned int x)
       
{
       
  // handle even numbers
       
  if ((x & 1) == 0)
       
    return x == 2;
       
 
       
  // lookup for odd numbers
       
  return sieve[x >> 1];
       
}
       
 
       
// find all prime numbers from 2 to size

       
void fillSieve(unsigned int size)
       
{
       
  // store only odd numbers
       
  const unsigned int half = (size >> 1) + 1;
       
 
       
  // allocate memory
       
  sieve.resize(half, true);
       
  // 1 is not a prime number
       
  sieve[0] = false;
       
 
       
  // process all relevant prime factors
       
  for (unsigned int i = 1; 2*i*i < half; i++)
       
    // do we have a prime factor ?
       
    if (sieve[i])
       
    {
       
      // mark all its multiples as false
       
      unsigned int current = 3*i+1;
       
      while (current < half)
       
      {
       
        sieve[current] = false;
       
        current += 2*i+1;
       
      }
       
    }
       
}
       
 
       
// ---------- problem specific code ----------

       
 
       
struct Term
       
{
       
  unsigned int prime;
       
  unsigned int exponent;
       
  unsigned long long value; // = pow(prime, exponent)
       
 
       
  // prime^exponent = value
       
  Term(unsigned int prime_, unsigned int exponent_, unsigned long long value_)
       
  : prime(prime_), exponent(exponent_), value(value_)
       
  {}
       
 
       
  // return a new Term with incremented exponent
       
  Term next() const
       
  {
       
    return Term(prime, 2 * exponent, value * value);
       
  }
       
 
       
  // deliberately ">" instead of "<" to convert max-heap to min-heap
       
  bool operator<(const Term& other) const
       
  {
       
    return value > other.value;
       
  }
       
};
       
 
       
unsigned int solve(unsigned int value, unsigned int modulo)
       
{
       
  // primes and their exponents to be considered next when computing the number
       
  std::priority_queue<Term> candidates;
       
 
       
  // fill with all primes^1
       
  unsigned int currentPrime = 1;
       
  while (candidates.size() < value)
       
  {
       
    ++currentPrime;
       
    while (!isPrime(currentPrime))
       
      currentPrime++;
       
 
       
    // prime^1 = prime
       
    candidates.emplace(Term(currentPrime, 1, currentPrime));
       
  }
       
 
       
  // primes and their exponents actually used for the number
       
  // [prime] => [prime^exponent] % modulo
       
  std::unordered_map<unsigned int, unsigned long long> choice;
       
 
       
  // iterate over all exponents
       
  for (unsigned int i = 0; i < value; i++)
       
  {
       
    // fetch smallest prime^exponent
       
    auto current = candidates.top();
       
 
       
    // store "new" prime or adjust existing
       
    if (choice.count(current.prime) == 0)
       
    {
       
      choice[current.prime]  = current.value;
       
    }
       
    else
       
    {
       
      choice[current.prime] *= current.value;
       
      choice[current.prime] %= modulo;
       
    }
       
 
       
    // update queue
       
    candidates.pop();
       
    candidates.push(current.next());
       
  }
       
 
       
  // multiply all values of used primes
       
  unsigned long long result = 1;
       
  for (auto x : choice)
       
    result = (result * x.second) % modulo;
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  // I need all primes up to 7370029 (determined by running the program multiple times)
       
  fillSieve(7400000);
       
 
       
  unsigned int exponent = 500500;
       
  std::cin  >> exponent;
       
  std::cout << solve(exponent, 500500507) << std::endl;
       
  return 0;
       
}

This solution contains 23 empty lines, 27 comments and 4 preprocessor commands.