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 <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;
       
 
       
  // 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 ----------

       
 
       
int main()
       
{
       
  unsigned long long limit = 10000000;
       
  std::cin >> limit;
       
 
       
  // compute all prime numbers
       
  fillSieve(limit / 2);
       
 
       
  // will contain the result
       
  unsigned long long sum = 0;
       
 
       
  // first prime
       
  for (unsigned long long i = 2; i*i <= limit; i++)
       
  {
       
    // primes only
       
    if (!isPrime(i))
       
      continue;
       
 
       
    // second prime
       
    unsigned long long j = (i == 2) ? 3 : i + 2; // somewhat tricky way to express: "next odd number, start with 3"
       
    for (; i*j <= limit; j += 2)
       
    {
       
      // primes only
       
      if (!isPrime(j))
       
        continue;
       
 
       
      // largest number expressed as i^something * j^somethingelse (<= limit)
       
      unsigned long long maxProduct = 0;
       
 
       
      // note: j needs to be long long because otherwise a few overflows
       
      //       lead to a result which is slightly off
       
 
       
      // i^1 * j^1
       
      auto product = i * j;
       
      // for i^1, i^2, i^3, ... find the maximum exponent for j
       
      do
       
      {
       
        // increase exponent of j as much as possible
       
        auto current = product;
       
        while (current * j <= limit)
       
          current *= j;
       
 
       
        // better than before ?
       
        if (maxProduct < current)
       
          maxProduct = current;
       
 
       
        // increment i's exponent by one
       
        product *= i;
       
      } while (product <= limit);
       
 
       
      // add all maximum products
       
      sum += maxProduct;
       
    }
       
  }
       
 
       
  // display result
       
  std::cout << sum << std::endl;
       
  return 0;
       
}

This solution contains 20 empty lines, 29 comments and 2 preprocessor commands.