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 <vector>
       
#include <iostream>
       
#include <algorithm>
       
 
       
// will be the result

       
std::vector<unsigned int> sums;
       
 
       
// return (a*b) % modulo

       
unsigned long long mulmod(unsigned long long a, unsigned long long b, unsigned long long modulo)
       
{
       
#ifdef __GNUC__
       
  // use GCC's optimized 128 bit code
       
  return ((unsigned __int128)a * b) % modulo;
       
#endif
       
 
       
  // (a * b) % modulo = (a % modulo) * (b % modulo) % modulo
       
  a %= modulo;
       
  b %= modulo;
       
 
       
  // fast path
       
  if (a <= 0xFFFFFFF && b <= 0xFFFFFFF)
       
    return (a * b) % modulo;
       
 
       
  // we might encounter overflows (slow path)
       
  // the number of loops depends on b, therefore try to minimize b
       
  if (b > a)
       
    std::swap(a, b);
       
 
       
  // bitwise multiplication
       
  unsigned long long result = 0;
       
  while (a > 0 && b > 0)
       
  {
       
    // b is odd ? a*b = a + a*(b-1)
       
    if (b & 1)
       
    {
       
      result += a;
       
      if (result >= modulo)
       
        result -= modulo;
       
      // skip b-- because the bit-shift at the end will remove the lowest bit anyway
       
    }
       
 
       
    // b is even ? a*b = (2*a)*(b/2)
       
    a <<= 1;
       
    if (a >= modulo)
       
      a -= modulo;
       
 
       
    // next bit
       
    b >>= 1;
       
  }
       
 
       
  return result;
       
}
       
 
       
// return (base^exponent) % modulo

       
unsigned long long powmod(unsigned long long base, unsigned long long exponent, unsigned long long modulo)
       
{
       
  unsigned long long result = 1;
       
  while (exponent > 0)
       
  {
       
    // fast exponentation:
       
    // odd exponent ? a^b = a*a^(b-1)
       
    if (exponent & 1)
       
      result = mulmod(result, base, modulo);
       
 
       
    // even exponent ? a^b = (a*a)^(b/2)
       
    base = mulmod(base, base, modulo);
       
    exponent >>= 1;
       
  }
       
  return result;
       
}
       
 
       
// Miller-Rabin-test

       
bool isPrime(unsigned long long p)
       
{
       
  // some code from             https://ronzii.wordpress.com/2012/03/04/miller-rabin-primality-test/
       
  // with optimizations from    http://ceur-ws.org/Vol-1326/020-Forisek.pdf
       
  // good bases can be found at http://miller-rabin.appspot.com/
       
 
       
  // trivial cases
       
  const unsigned int bitmaskPrimes2to31 = (1 <<  2) | (1 <<  3) | (1 <<  5) | (1 <<  7) |
       
                                          (1 << 11) | (1 << 13) | (1 << 17) | (1 << 19) |
       
                                          (1 << 23) | (1 << 29); // = 0x208A28Ac
       
  if (p < 31)
       
    return (bitmaskPrimes2to31 & (1 << p)) != 0;
       
 
       
  if (p %  2 == 0 || p %  3 == 0 || p %  5 == 0 || p % 7 == 0 || // divisible by a small prime
       
      p % 11 == 0 || p % 13 == 0 || p % 17 == 0)
       
    return false;
       
 
       
  if (p < 17*19) // we filtered all composite numbers < 17*19, all others below 17*19 must be prime
       
    return true;
       
 
       
  // test p against those numbers ("witnesses")
       
  // good bases can be found at http://miller-rabin.appspot.com/
       
  const unsigned int STOP = 0;
       
  const unsigned int TestAgainst1[] = { 377687, STOP };
       
  const unsigned int TestAgainst2[] = { 31, 73, STOP };
       
  const unsigned int TestAgainst3[] = { 2, 7, 61, STOP };
       
  // first three sequences are good up to 2^32
       
  const unsigned int TestAgainst4[] = { 2, 13, 23, 1662803, STOP };
       
  const unsigned int TestAgainst7[] = { 2, 325, 9375, 28178, 450775, 9780504, 1795265022, STOP };
       
 
       
  // good up to 2^64
       
  const unsigned int* testAgainst = TestAgainst7;
       
  // use less tests if feasible
       
  if (p < 5329)
       
    testAgainst = TestAgainst1;
       
  else if (p < 9080191)
       
    testAgainst = TestAgainst2;
       
  else if (p < 4759123141ULL)
       
    testAgainst = TestAgainst3;
       
  else if (p < 1122004669633ULL)
       
    testAgainst = TestAgainst4;
       
 
       
  // find p - 1 = d * 2^j
       
  auto d = p - 1;
       
  d >>= 1;
       
  unsigned int shift = 0;
       
  while ((d & 1) == 0)
       
  {
       
    shift++;
       
    d >>= 1;
       
  }
       
 
       
  // test p against all bases
       
  do
       
  {
       
    auto x = powmod(*testAgainst++, d, p);
       
    // is test^d % p == 1 or -1 ?
       
    if (x == 1 || x == p - 1)
       
      continue;
       
 
       
    // now either prime or a strong pseudo-prime
       
    // check test^(d*2^r) for 0 <= r < shift
       
    bool maybePrime = false;
       
    for (unsigned int r = 0; r < shift; r++)
       
    {
       
      // x = x^2 % p
       
      // (initial x was test^d)
       
      x = powmod(x, 2, p);
       
      // x % p == 1 => not prime
       
      if (x == 1)
       
        return false;
       
 
       
      // x % p == -1 => prime or an even stronger pseudo-prime
       
      if (x == p - 1)
       
      {
       
        // next iteration
       
        maybePrime = true;
       
        break;
       
      }
       
    }
       
 
       
    // not prime
       
    if (!maybePrime)
       
      return false;
       
  } while (*testAgainst != STOP);
       
 
       
  // prime
       
  return true;
       
}
       
 
       
// merge two numbers, "append their digits"

       
unsigned long long merge(unsigned long long a, unsigned long long b)
       
{
       
  // merge(12, 34) => 1234
       
  unsigned long long shift = 10;
       
  while (shift <= b)
       
    shift *= 10;
       
  return a * shift + b;
       
}
       
 
       
// true if a and b can be merged in any way and the result is still a prime

       
bool match(unsigned long long a, unsigned long long b)
       
{
       
  return isPrime(merge(a, b)) && isPrime(merge(b, a));
       
}
       
 
       
// find all triplets:
       
// all numbers in "candidates" already match with first
       
// now we have to check every numbers in "candidates" against each other

       
void checkTriple(unsigned int first, const std::vector<unsigned int>& candidates)
       
{
       
  for (size_t index2 = 0; index2 < candidates.size(); index2++)
       
    for (size_t index3 = index2 + 1; index3 < candidates.size(); index3++)
       
      // match ?
       
      if (match(candidates[index2], candidates[index3]))
       
      {
       
        // append sum to result set
       
        auto sum = first + candidates[index2] + candidates[index3];
       
        sums.push_back(sum);
       
      }
       
}
       
 
       
// find all quadruples, same idea as checkTriple, but this time 1+3 number must match

       
void checkQuadruple(unsigned int first, const std::vector<unsigned int>& candidates)
       
{
       
  for (size_t index2 = 0; index2 < candidates.size(); index2++)
       
    for (size_t index3 = index2 + 1; index3 < candidates.size(); index3++)
       
    {
       
      // not even a triple ?
       
      if (!match(candidates[index2], candidates[index3]))
       
        continue;
       
 
       
      // match fourth number
       
      for (size_t index4 = index3 + 1; index4 < candidates.size(); index4++)
       
        if (match(candidates[index2], candidates[index4]) &&
       
            match(candidates[index3], candidates[index4]))
       
        {
       
          // append sum to result set
       
          auto sum = first + candidates[index2] + candidates[index3] + candidates[index4];
       
          sums.push_back(sum);
       
        }
       
    }
       
}
       
 
       
// find all quintuples, same idea as above, just nested one level deeper

       
void checkQuintuple(unsigned int first, const std::vector<unsigned int>& candidates)
       
{
       
  for (size_t index2 = 0; index2 < candidates.size(); index2++)
       
    for (size_t index3 = index2 + 1; index3 < candidates.size(); index3++)
       
    {
       
      // not even a triple ?
       
      if (!match(candidates[index2], candidates[index3]))
       
        continue;
       
 
       
      for (size_t index4 = index3 + 1; index4 < candidates.size(); index4++)
       
      {
       
        // not even a quadruple ?
       
        if (!match(candidates[index2], candidates[index4]) ||
       
            !match(candidates[index3], candidates[index4]))
       
          continue;
       
 
       
        // match fifth number
       
        for (size_t index5 = index4 + 1; index5 < candidates.size(); index5++)
       
          if (match(candidates[index2], candidates[index5]) &&
       
              match(candidates[index3], candidates[index5]) &&
       
              match(candidates[index4], candidates[index5]))
       
          {
       
            // append sum to result set
       
            auto sum = first + candidates[index2] + candidates[index3] +
       
                               candidates[index4] + candidates[index5];
       
            sums.push_back(sum);
       
          }
       
      }
       
    }
       
}
       
 
       
int main()
       
{
       
  // all primes are below this threshold
       
  unsigned int maxPrime = 20000;
       
  // number of primes in a group
       
  unsigned int size     =     5;
       
  std::cin >> maxPrime >> size;
       
 
       
  // all primes that can be part of a result set
       
  std::vector<unsigned int> primes;
       
  // find all primes up to n (20000 at most)
       
  // note: 2 is deliberately excluded because "any combination must be a prime"
       
  // => but any number where we concat 2 to the end can't be prime
       
  for (unsigned int i = 3; i < maxPrime; i += 2)
       
  {
       
    bool isPrime = true;
       
    for (auto p : primes)
       
    {
       
      if (p*p > i)
       
        break;
       
      if (i % p == 0)
       
      {
       
        isPrime = false;
       
        break;
       
      }
       
    }
       
 
       
    if (isPrime)
       
      primes.push_back(i);
       
  }
       
 
       
  for (size_t i = 0; i < primes.size(); i++)
       
  {
       
    auto smallPrime = primes[i];
       
    // no prime number ends with 5 (except 5 itself) => just a simple performance tweak
       
    if (smallPrime == 5)
       
      continue;
       
 
       
    // find all larger primes that can be paired with "smallPrime"
       
    std::vector<unsigned int> candidates;
       
    for (size_t j = i + 1; j < primes.size(); j++)
       
    {
       
      auto largePrime = primes[j];
       
      if (match(smallPrime, largePrime))
       
        candidates.push_back(largePrime);
       
    }
       
 
       
    // all other candidates must be "pairable" to each other, too
       
    if (size == 3)
       
      checkTriple(smallPrime, candidates);
       
    else if (size == 4)
       
      checkQuadruple(smallPrime, candidates);
       
    else // size == 5
       
      checkQuintuple(smallPrime, candidates);
       
  }
       
 
       
  // print all sums in ascending order, some sums may occur multiple times
       
  std::sort(sums.begin(), sums.end());
       
  for (auto s : sums)
       
    std::cout << s << std::endl;
       
}

This solution contains 38 empty lines, 65 comments and 5 preprocessor commands.