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) + 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;
       
      }
       
    }
       
}
       
 
       
// ---------- powmod is part of my toolbox, too ----------

       
 
       
// return (base^exponent) % modulo for 32-bit values, no need for mulmod

       
unsigned int powmod(unsigned int base, unsigned int exponent, unsigned int modulo)
       
{
       
  unsigned int result = 1;
       
  while (exponent > 0)
       
  {
       
    // fast exponentation:
       
    // odd exponent ? a^b = a*a^(b-1)
       
    if (exponent & 1)
       
      result = (result * (unsigned long long)base) % modulo;
       
 
       
    // even exponent ? a^b = (a*a)^(b/2)
       
    base = (base * (unsigned long long)base) % modulo;
       
    exponent >>= 1;
       
  }
       
  return result;
       
}
       
 
       
// ---------- problem-specific code ----------

       
 
       
unsigned long long solve(unsigned int limit, unsigned int modulo)
       
{
       
  unsigned long long result = 1;
       
 
       
  // find all prime numbers
       
  fillSieve(limit);
       
 
       
  for (unsigned int p = 2; p <= limit; p++)
       
  {
       
    // prime factors only
       
    if (!isPrime(p))
       
      continue;
       
 
       
    // will be p^1, p^2, p^3, p^4, ...
       
    unsigned long long power = p;
       
    // count how often current prime appears in factorial(limit)
       
    unsigned int count = 0;
       
    while (power <= limit)
       
    {
       
      // fast check for large powers
       
      if (2*power > limit)
       
      {
       
        count++;
       
        break;
       
      } // note: this if-block can be removed and you still get the correct result - albeit slower
       
 
       
      // count multiples
       
      auto multiples = limit / power;
       
      count += multiples;
       
      power *= p;
       
    }
       
 
       
    // (p*p)^x = p^2x
       
    // => p*p can be 64 bits and powmod for 64 bits is more complex and much slower
       
    result *= 1 + powmod(p, 2*count, modulo);
       
    result %= modulo;
       
  }
       
 
       
  return result;
       
}
       
 
       
int main()
       
{
       
  const unsigned int Modulo = 1000000009;
       
  unsigned int limit = 100000000; // 10^8
       
  std::cin >> limit;
       
 
       
  std::cout << solve(limit, Modulo) << std::endl;
       
  return 0;
       
}

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