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>
       
 
       
// last five digits

       
const unsigned int Modulo = 100000;
       
 
       
// ---------- powmod was taken from my toolbox ----------

       
 
       
// return (base^exponent) % modulo

       
unsigned int powmod(unsigned int base, unsigned long long 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 = ((unsigned long long)result * base) % modulo;
       
 
       
    // even exponent ? a^b = (a*a)^(b/2)
       
    base = ((unsigned long long)base * base) % modulo;
       
    exponent >>= 1;
       
  }
       
  return result;
       
}
       
 
       
// ---------- and now my first "brute force" algorithm ----------

       
 
       
unsigned int algorithm1(unsigned long long limit)
       
{
       
  // process ten numbers in one iteration
       
  unsigned long long iterations = limit / 10;
       
 
       
  // count "excess"/"spare" twos that can be used whenever I encounter a five (2*5=10)
       
  unsigned long long twos = 0;
       
 
       
  // find last five digits of (2*3*6*7*8*9)^iterations
       
  // note: the 4 is missing because sometimes I need a few "spare" twos
       
  unsigned long long result = powmod(1*2*3*6*7*8*9, iterations, Modulo);
       
 
       
  // process numbers 10i+1, 10i+2, 10i+3, ..., 10i+10
       
  for (unsigned long long i = 0; i < iterations; i++)
       
  {
       
    // enough "spare" twos ?
       
    if (twos > 100) // 100 was chosen "at random" but even 10 works fine
       
      // yes, no need to hold back a few twos (2*2=4)
       
      result *= 4;
       
    else
       
      // not enough "spare" twos, avoid multiplying by 4 and hold back 2 twos
       
      twos   += 2;
       
 
       
    // five = (i*10 + 5) / 5 = i*2 + 1
       
    auto five = i*2 + 1;
       
    // need one "spare" two
       
    twos--;
       
    // as long as it's still a multiple of 5 ...
       
    while (five % 5 == 0)
       
    {
       
      five /= 5;
       
      twos--; // and need one more "spare" two
       
    }
       
    result *= five % Modulo;
       
 
       
    // ten = (i*10 + 10) = i + 1
       
    auto ten = i + 1;
       
    // note: unlike five, now no "spare" two is needed
       
 
       
    // same loop as used for five ...
       
    while (ten % 5 == 0)
       
    {
       
      ten /= 5;
       
      twos--; //
       
    }
       
    result *= ten % Modulo;
       
 
       
    // keep only the last five digits
       
    result %= Modulo;
       
  }
       
 
       
  // multiply with remaining "spare" twos
       
  while (twos-- > 0)
       
    result = (result * 2) % Modulo;
       
 
       
  return result;
       
}
       
 
       
// ---------- a very basic algorithm, sufficient for f(2560000) ----------

       
 
       
unsigned int algorithm2(unsigned long long limit)
       
{
       
  unsigned long long result = 1;
       
  // multiply all numbers
       
  for (unsigned long long i = 1; i <= limit; i++)
       
  {
       
    auto current = i;
       
    // divisible by 5 ?
       
    while (current % 5 == 0)
       
    {
       
      current /= 5;
       
      // there were at least the same number of twos
       
      result  /= 2;
       
    }
       
 
       
    result *= current % Modulo;
       
    // note: I can't use % Modulo because whenever a 5 appear, I divide by 2, too
       
    //       and therefore can't erase too many digits higher than 10^5
       
    result %= 1000000000ULL;
       
  }
       
 
       
  // reduce to five digits
       
  return result % Modulo;
       
}
       
 
       
int main()
       
{
       
  // 10^12
       
  auto limit = 1000000000000ULL;
       
  std::cin >> limit;
       
 
       
  // f(5^k * n) = f(n) until n%10000 != 0
       
  while (limit % Modulo == 0)
       
    limit /= 5;
       
 
       
  if (limit > 2560000)
       
    // faster algorithm
       
    std::cout << algorithm1(limit) << std::endl;
       
  else
       
    // simpler algorithm
       
    std::cout << algorithm2(limit) << std::endl;
       
 
       
  return 0;
       
}

This solution contains 23 empty lines, 34 comments and 1 preprocessor command.