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>
       
 
       
std::vector<unsigned int> primes;
       
 
       
// return Euler totient (taken from problem 70 and slightly modified)

       
unsigned int phi(unsigned int x)
       
{
       
  // totient function can be computed by finding all prime factors p
       
  // and subtracting them from x
       
  auto result  = x;
       
  auto reduced = x;
       
  for (auto p : primes)
       
  {
       
    // prime factors have to be p <= sqrt
       
    if (p*p > reduced)
       
      break;
       
 
       
    // not a prime factor ...
       
    if (reduced % p != 0)
       
      continue;
       
 
       
    // prime factors may occur multiple times, remove them all
       
    do
       
    {
       
      reduced /= p;
       
    } while (reduced % p == 0);
       
 
       
    // but subtract from result only once
       
    result -= result / p;
       
  }
       
 
       
  // we only checked prime factors <= sqrt(x)
       
  // there might exist one (!) prime factor > sqrt(x)
       
  // e.g. 3 is a prime factor of 6, and 3 > sqrt(6)
       
  if (reduced > 1)
       
    result -= result / reduced;
       
 
       
  return result;
       
}
       
 
       
// count length of totient chain, abort if more than maxSteps

       
unsigned int steps(unsigned int x, unsigned int maxSteps)
       
{
       
  unsigned int result = 1; // initial value is counted as a step, too
       
 
       
  // if x is prime, then phi(x) = x - 1
       
  x--;
       
  result++;
       
 
       
  // follow chain until we hit 1 or the chain becomes too long
       
  while (x > 1 && result < maxSteps)
       
  {
       
    // one more step ...
       
    x = phi(x);
       
    result++;
       
 
       
    // power of two ? (only a single bit set)
       
    if ((x & (x - 1)) == 0)
       
    {
       
      // simple chain for powers of two:
       
      // ... => 1024 => 512 => 256 => 128 => ... => 4 => 2 => 1
       
      while (x > 1)
       
      {
       
        x >>= 1;
       
        result++;
       
      }
       
    }
       
  }
       
 
       
  return result;
       
}
       
 
       
// sieve is copied 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;
       
      }
       
    }
       
}
       
 
       
int main()
       
{
       
  unsigned long long result = 0;
       
 
       
  unsigned int limit = 40000000;
       
  unsigned int maxSteps = 25;
       
  std::cin >> maxSteps >> limit;
       
 
       
  // start the prime sieve
       
  fillSieve(limit);
       
 
       
  // convert sieve to a "denser" data structure for phi(x)
       
  primes.push_back(2);
       
 
       
  for (unsigned int i = 3; i < limit; i += 2)
       
  {
       
    // check bits in sieve
       
    if (!isPrime(i))
       
      continue;
       
 
       
    // phi(i) needs only primes smaller than sqrt(i)
       
    if (i*i <= limit)
       
      primes.push_back(i);
       
 
       
    // primes need to be quite large to generate a long chain ...
       
    if (maxSteps == 25 && i < 9548417) // note: "magic constant" found in experiments
       
      continue;
       
 
       
    // compute chain
       
    unsigned int current = steps(i, maxSteps + 1);
       
    if (current == maxSteps)
       
      result += i;
       
  }
       
 
       
  std::cout << result << std::endl;
       
  return 0;
       
}

This solution contains 28 empty lines, 35 comments and 2 preprocessor commands.