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>
       
#include <string>
       
 
       
// ---------- code taken from my toolbox, with a few modifications / extensions, see explanations above ----------

       
 
       
// store single digits with lowest digits first
       
// e.g. 1024 (in base 14) is stored as { 4,2,0,1 }
       
// only non-negative numbers supported

       
struct BigNum : public std::vector<unsigned char>
       
{
       
  static const unsigned int MaxDigit = 14;
       
 
       
  // store a non-negative number
       
  BigNum(unsigned int x = 0)
       
  {
       
    do
       
    {
       
      push_back(x % MaxDigit);
       
      x /= MaxDigit;
       
    } while (x > 0);
       
  }
       
 
       
  // convert from base 14 to string
       
  std::string toString() const
       
  {
       
    const char digits[] = "0123456789abcd";
       
 
       
    std::string result;
       
    for (auto x : *this)
       
    {
       
      // process a bucket
       
      for (unsigned int shift = 1; shift < MaxDigit; shift *= MaxDigit)
       
      {
       
        auto digit = (x / shift) % MaxDigit;
       
        result.insert(0, 1, digits[digit]);
       
      }
       
    }
       
 
       
    // remove leading zeros
       
    while (result.size() > 1 && result.front() == '0')
       
      result.erase(0, 1);
       
 
       
    return result;
       
  }
       
 
       
  // add two big numbers
       
  BigNum operator+(const BigNum& other) const
       
  {
       
    auto result = *this;
       
    // add in-place, make sure it's big enough
       
    if (result.size() < other.size())
       
      result.resize(other.size(), 0);
       
 
       
    unsigned int carry = 0;
       
    for (size_t i = 0; i < result.size(); i++)
       
    {
       
      carry += result[i];
       
      if (i < other.size())
       
        carry += other[i];
       
      else
       
        if (carry == 0)
       
          return result;
       
 
       
      if (carry < MaxDigit)
       
      {
       
        // no overflow
       
        result[i] = carry;
       
        carry     = 0;
       
      }
       
      else
       
      {
       
        // yes, we have an overflow
       
        result[i] = carry - MaxDigit;
       
        carry = 1;
       
      }
       
    }
       
 
       
    if (carry > 0)
       
      result.push_back(carry);
       
 
       
    return result;
       
  }
       
 
       
  // multiply a big number by an integer
       
  BigNum operator*(unsigned int factor) const
       
  {
       
    // faster multiplication possible ?
       
    if (factor == 0)
       
      return 0;
       
    if (factor == 1)
       
      return *this;
       
    if (factor == MaxDigit)
       
    {
       
      if (size() == 1 && operator[](0) == 0)
       
        return 0;
       
 
       
      auto result = *this;
       
      result.insert(result.begin(), 0);
       
      return result;
       
    }
       
 
       
    unsigned int carry = 0;
       
    auto result = *this;
       
    for (auto& i : result)
       
    {
       
      carry += i * factor;
       
      i      = carry % MaxDigit;
       
      carry /= MaxDigit;
       
    }
       
    // store remaining carry in new digits
       
    while (carry > 0)
       
    {
       
      result.push_back(carry % MaxDigit);
       
      carry /= MaxDigit;
       
    }
       
 
       
    return std::move(result);
       
  }
       
 
       
  // subtract a smaller-or-equal number
       
  BigNum operator-(const BigNum& other) const
       
  {
       
    BigNum result = *this;
       
    int borrow = 0;
       
    for (size_t i = 0; i < result.size(); i++)
       
    {
       
      int diff = (int)result[i] - borrow;
       
      if (i < other.size())
       
        diff -= other[i];
       
      else
       
        if (borrow == 0)
       
          break;
       
 
       
      if (diff < 0)
       
      {
       
        borrow = 1;
       
        diff += MaxDigit;
       
      }
       
      else
       
        borrow = 0;
       
 
       
      result[i] = diff;
       
    }
       
 
       
    // no high zeros
       
    while (result.size() > 1 && result.back() == 0)
       
      result.pop_back();
       
 
       
    return result;
       
  }
       
 
       
  // multiply two big numbers
       
  BigNum operator*(const BigNum& other) const
       
  {
       
    if (size() < other.size())
       
      return other * *this;
       
 
       
    // multiply single digits of "other" with the current object
       
    BigNum result = 0;
       
    for (int i = (int)other.size() - 1; i >= 0; i--)
       
      result = result * MaxDigit + (*this * other[i]);
       
 
       
    return std::move(result);
       
  }
       
 
       
// ---------- problem-specific code (still part of BigNum class) ----------

       
 
       
  // multiply by a big number and keep only the lowest digits
       
  void multiplyLow(const BigNum& other, size_t numDigits)
       
  {
       
    BigNum result;
       
    result.resize(numDigits, 0);
       
 
       
    // multiply single digits of "other" with the current object
       
    unsigned int carry = 0;
       
    for (size_t i = 0; i < other.size() && i < numDigits; i++)
       
    {
       
      carry = 0;
       
      for (size_t j = 0; i + j < numDigits; j++)
       
      {
       
        // multiply two digits (if possible) and add carry
       
        if (j >= size())
       
          carry += result[i + j];
       
        else
       
          carry += result[i + j] + other[i] * operator[](j);
       
 
       
        // store lowest digit of product and keep "carrying on" :-)
       
        result[i + j] = carry % MaxDigit;
       
        carry /= MaxDigit;
       
      }
       
    }
       
 
       
    *this = std::move(result);
       
  }
       
 
       
  // try to find the square and check whether its lower digits remain unchanged
       
  bool isSteady() const
       
  {
       
    // multiply the number with itself and abort as soon as possible
       
    BigNum square = 0;
       
 
       
    for (size_t pos = 0; pos < size(); pos++)
       
    {
       
      // multiply with next digit
       
      auto digit = operator[](pos);
       
      if (digit > 0)
       
      {
       
        auto product = *this * digit;
       
 
       
        for (size_t appendZeros = 0; appendZeros < pos; appendZeros++)
       
          product.insert(product.begin(), 0);
       
        square = square + product;
       
      }
       
 
       
      // mismatch ?
       
      if (digit != square[pos])
       
        return false;
       
    }
       
 
       
    // yes, a steady square
       
    return true;
       
  }
       
};
       
 
       
// ---------- problem-specific code (not part of BigNum class) ----------

       
 
       
// prepend every possible digit until a steady square is fouund

       
BigNum bruteForce(const BigNum& number)
       
{
       
  auto next = number;
       
  next.push_back(0);
       
 
       
  // prepend a digit (remember: digits are stored in reverse order)
       
  for (unsigned int digit = 0; digit < BigNum::MaxDigit; digit++)
       
  {
       
    next.back() = digit;
       
    // steady ?
       
    if (next.isSteady())
       
      break;
       
  }
       
  return next;
       
}
       
 
       
// compute steady square where the right-most digits are "number", result has exactly "numDigits" digits

       
BigNum fastDoubling(const BigNum& number, unsigned int numDigits)
       
{
       
  // https://en.wikipedia.org/wiki/Automorphic_number
       
  // n' = (3n^2 - 2n^3) mod 14^2k          => a negative number, which my simple BigNum class doesn't support yet
       
  // n' = 14^2k - (2n^3 - 3n^2) mod 14^2k
       
 
       
  // after each iteration, the number of steady digits will double
       
  auto current = number;
       
  while (current.size() < numDigits)
       
  {
       
    // new number will have twice as many digits
       
    auto twiceDigits = 2 * current.size();
       
 
       
    auto square = current * current;     // n^2
       
    auto cube   = square  * current;     // n^3
       
    auto diff   = cube * 2 - square * 3; // 3n^2 - 2n^3
       
 
       
    diff.resize(twiceDigits);            // (3n^2 - 2n^3) mod 14^twiceDigits
       
 
       
    BigNum largeOne = 0;
       
    largeOne.resize(twiceDigits, 0);     // 14*twiceDigits zeros
       
    largeOne.push_back(1);               // and prepend a "1" => 14^twiceDigits
       
 
       
    current = largeOne - diff;           // 14^twiceDigits - (3n^2 - 2n^3) mod 14^twiceDigits
       
  }
       
 
       
  // remove superfluous leading digits (current has always 2^iterations digits, e.g. 16384 which will be reduced to 10000)
       
  current.resize(numDigits);
       
  return current;
       
}
       
 
       
// given an automorphic number, find its sibling

       
BigNum findOther(const BigNum& number)
       
{
       
  // eight = (14^maxDigits + 1) - seven
       
  BigNum one0one = 1;
       
  one0one.resize(number.size(), 0);
       
  one0one.push_back(1);
       
  return one0one - number;
       
}
       
 
       
int main()
       
{
       
  unsigned int maxDigits = 10000;
       
  std::cin >> maxDigits;
       
 
       
  // manually found those two number to be the only steady digits mod 14 (except for 1, see below)
       
  BigNum seven = 7;
       
  BigNum eight = 8;
       
 
       
//#define BRUTEFORCE

       
#ifdef  BRUTEFORCE
       
  // brute-force
       
  for (unsigned int i = 2; i < maxDigits; i++)
       
  {
       
    seven = bruteForce(seven);
       
    eight = bruteForce(eight);
       
  }
       
#endif
       
 
       
//#define POWER

       
#ifdef  POWER
       
  for (unsigned int numDigits = 2; numDigits <= maxDigits; numDigits++)
       
  {
       
    // seven = seven * seven, reduced to numDigits
       
    seven.multiplyLow(seven, numDigits);
       
    //std::cout << numDigits << " " << std::flush;
       
  }
       
  eight = findOther(seven);
       
#endif
       
 
       
#define DOUBLING
       
#ifdef  DOUBLING
       
  // use equation (3n^2 - 2n^3) mod 14^k until I have 10000 digits
       
  seven = fastDoubling(7, maxDigits);
       
  eight = findOther(seven); // faster than eight = fastDoubling(8, maxDigits);
       
#endif
       
 
       
  // now I have the 10000 steady digits ending with 7 and 8, let's find their digit sum !
       
 
       
  // 1 is a steady digit, too, but a strange special case: 1^2 % 14 = 1
       
  unsigned int sum = 1;
       
  // prepending any digit to 1 doesn't produce a steady square
       
 
       
  // okay, let's proceed with ...7 and ...8
       
  for (unsigned int i = 0; i < maxDigits; i++)
       
  {
       
    // last digit appears in 10000 steady squares, next to last in 9999 steady squares, ...
       
    auto howOften = maxDigits - i;
       
    sum += howOften * seven[i];
       
    sum += howOften * eight[i];
       
 
       
    // but don't count those numbers having a leading zero
       
    if (seven[i] == 0)
       
      for (unsigned int j = 0; j < i; j++) // could be more efficient ... but it's still too fast to be measurable
       
        sum -= seven[j];
       
 
       
    if (eight[i] == 0)
       
      for (unsigned int j = 0; j < i; j++)
       
        sum -= eight[j];
       
  }
       
 
       
  // print digit sum in base 14
       
  BigNum sumBase14 = sum;
       
  std::cout << sumBase14.toString() << std::endl;
       
  return 0;
       
}

This solution contains 56 empty lines, 56 comments and 10 preprocessor commands.