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>
       
 
       
// 2000x2000 matrix

       
const size_t size = 2000;
       
int* data = NULL;
       
 
       
// find maximum sum of all elements from data[first] to data[last]

       
int maxSum(size_t first, size_t last, size_t increment)
       
{
       
  // Kadane's algorithm
       
  // https://en.wikipedia.org/wiki/Maximum_subarray_problem
       
  int result = data[first];
       
  int currentSum = 0;
       
  for (auto i = first; i <= last; i += increment)
       
  {
       
    // "extend" current sum
       
    currentSum += data[i];
       
 
       
    // if sum is negative then there must be single element bigger or equal
       
    // which is already stored in result
       
    if (currentSum < 0)
       
      currentSum = 0;
       
 
       
    // improved sum ?
       
    if (result < currentSum)
       
      result = currentSum;
       
  }
       
 
       
  return result;
       
}
       
 
       
// fill 2000x2000 matrix

       
void fillLaggedFibonacciSequence()
       
{
       
  // fill elements in consecutive order
       
  int *current = data;
       
 
       
  // initial 55 elements
       
  long long k = 1; // note: if only int is used, then k*k*k overflows !
       
  while (k <= 55)
       
  {
       
    *current++ = ((100003 - 200003 * k + 300007 * k*k*k) % 1000000) - 500000;
       
    k++;
       
  }
       
  // ... to infinity and beyond !
       
  while (current < data + size*size)
       
    *current++ = ((current[-24] + current[-55] + 1000000) % 1000000) - 500000;
       
}
       
 
       
// convert 2D coordinate to a linear 1D coordinate

       
size_t index(size_t x, size_t y)
       
{
       
  return y * size + x;
       
}
       
 
       
int main()
       
{
       
  // allocate memory
       
  data = new int[size*size];
       
  // generate sequence
       
  fillLaggedFibonacciSequence();
       
 
       
  auto last = size - 1;
       
  auto result = data[0];
       
 
       
  // horizontal
       
  for (size_t y = 0; y <= last; y++)
       
  {
       
    auto current = maxSum(index(0, y), index(last, y), 1);
       
    if (result < current)
       
      result = current;
       
  }
       
 
       
  // vertical
       
  for (size_t x = 0; x <= last; x++)
       
  {
       
    auto current = maxSum(index(x, 0), index(x, last), size);
       
    if (result < current)
       
      result = current;
       
  }
       
 
       
  // diagonal \ => from upper to right edge
       
  for (size_t x = 0; x <= last; x++)
       
  {
       
    auto current = maxSum(index(x, 0), index(last, last - x), size + 1);
       
    if (result < current)
       
      result = current;
       
  }
       
 
       
  // diagonal \ => from left to lower edge
       
  for (size_t y = 1; y <= last; y++) // y = 0 was already checked by previous loop
       
  {
       
    auto current = maxSum(index(0, y), index(y, last), size + 1);
       
    if (result < current)
       
      result = current;
       
  }
       
 
       
  // diagonal / => from upper to left edge
       
  for (size_t x = 0; x <= last; x++)
       
  {
       
    auto current = maxSum(index(x, 0), index(0, x), size - 1);
       
    if (result < current)
       
      result = current;
       
  }
       
 
       
  // diagonal / => from right to lower edge
       
  for (size_t y = 1; y <= last; y++) // y = 0 was already checked by previous loop
       
  {
       
    auto current = maxSum(index(last, y), index(y, last), size - 1);
       
    if (result < current)
       
      result = current;
       
  }
       
 
       
  std::cout << result << std::endl;
       
  delete[] data;
       
 
       
  return 0;
       
}

This solution contains 18 empty lines, 21 comments and 2 preprocessor commands.