Go: package main

import (
	"bufio"
	"os"
	"strconv"
	"fmt"
	"strings"
	"sort"
)

var scanner= bufio.NewScanner(os.Stdin)

func main() {
	for scanner.Scan() {
		n, _ := strconv.Atoi(scanner.Text())
		if n == 0 {
			break
		}
		mp := make([]string, n)
		for i := range mp {
			scanner.Scan()
			mp[i] = "0" + scanner.Text() + "0"
		}
		tmp := make([]string, n+2)
		for i := range tmp {
			tmp[i] = "0"
		}
		mp = append([]string{strings.Join(tmp, "")}, mp...)
		mp = append(mp, strings.Join(tmp, ""))
		score := make([][][]int, n+2)
		for i := range score {
			score[i] = make([][]int, n+2)
			for j := range score[i] {
				score[i][j] = make([]int, 4)
			}
		}
		max_score := 0
		for i := 1; i < n+1; i++ {
			for j := 1; j < n+1; j++ {
				tmps := mp[i]
				if string(tmps[j]) == "1" {
					score[i][j][0] = score[i - 1][j][0] + 1
					score[i][j][1] = score[i][j - 1][1] + 1
					score[i][j][2] = score[i - 1][j - 1][2] + 1
					score[i][j][3] = score[i - 1][j + 1][3] + 1
					max_score = max(max_score, score[i][j][0], score[i][j][1], score[i][j][2], score[i][j][3])
				}
			}
		}
		fmt.Println(max_score)
	}
}

func max(a, b, c, d, e int) int {
	buf := []int{a, b, c, d, e}
	sort.Ints(buf)
	return buf[len(buf)-1]
}

C++: #include <bits/stdc++.h>
using namespace std ;

#define pb(n) push_back(n)
#define fi first
#define se second
#define all(r) (r).begin(),(r).end()
#define gsort(st,en) sort((st),(en),greater<int>())
#define vmax(ary) *max_element(all(ary))
#define vmin(ary) *min_element(all(ary))
#define debug(x) cout<<#x<<": "<<x<<endl
#define fcout(n) cout<<fixed<<setprecision((n))
#define scout(n) cout<<setw(n)
#define vary(type,name,size,init) vector< type> name(size,init)

#define rep(i,n) for(int i = 0; i < (int)(n);++i)
#define REP(i,a,b) for(int i = (a);i < (int)(b);++i)
#define repi(it,array) for(auto it = array.begin(),end = array.end(); it != end;++it)
#define repa(n,array) for(auto &n :(array))

using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using dict = map<string,int>;
using pii = pair<int,int> ;

constexpr int imax = ((1<<30)-1)*2+1 ;
constexpr int inf = 100000000;
constexpr double PI = acos(-1.0) ;
double eps = 1e-10 ;
const int dy[] = {-1,0,1,0};
const int dx[] = {0,-1,0,1};

inline bool value(int x,int y,int w,int h){
  return (x >= 0 && x < w && y >= 0 && y < h);
}

template<typename T>
void Unique(vector<T> &v){
  sort(all(v));
  v.erase(unique(all(v)),v.end());
}

template<typename T>
T ston(string& str, T n){
  istringstream sin(str) ;
  T num ;
  sin >> num ;
  return num ;
}

void Ans(bool f){
  if(f) cout << "YES"<<endl;
  else cout << "NO"<<endl;
}

int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n;
  while(cin>>n && n){
    vector<vector<char>> vc(n,vector<char>(n,' '));
    rep(i,n){
      rep(j,n){
        cin >>vc[j][i];
        vc[j][i] -= '0';
      }
    }
    auto tmp = vc;
    char ma = 0;
    rep(i,n){
      rep(j,n){
        if( j > 0 && tmp[j][i]){
          tmp[j][i] += tmp[j-1][i];
        }
        ma = max(ma,tmp[j][i]);
      }
    }
    tmp = vc;
    rep(j,n){
      rep(i,n){
        if( i > 0 && tmp[j][i]){
          tmp[j][i] += tmp[j][i-1];
        }
        ma = max(ma,tmp[j][i]);
      }
    }
    tmp = vc;
    rep(i,n){
      rep(j,n){
        if( j < n-1 && i > 0&& tmp[j][i]){
          tmp[j][i] += tmp[j+1][i-1];
        }
        ma = max(ma,tmp[j][i]);
      }
    }
    tmp = vc;
    rep(i,n){
      rep(j,n){
        if( j > 0 && i > 0 && tmp[j][i]){
          tmp[j][i] += tmp[j-1][i-1];
        }
        ma = max(ma,tmp[j][i]);
      }
    }
    cout << (int)ma << endl;
  }
  return 0;
}

C++: #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cassert>
#include <cmath>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;

typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PLL;

constexpr int dx[4] = {-1, -1, -1, 0};
constexpr int dy[4] = {1, 0, -1, -1};

bool solve() {
    int N;
    string d[255];
    cin >> N; if (N == 0) { return false; }

    for (int j = 0; j < N; ++j) {
        cin >> d[j];
    }

    int dp[255][255][4];
    for (int j = 0; j < N; ++j) {
        for (int k = 0; k < N; ++k) {
            fill(dp[j][k], dp[j][k]+4, 0);
        }
    }

    int ret = 0;

    for (int j = 0; j < N; ++j) {
        for (int k = 0; k < N; ++k) {
            if (d[j][k] == '0') { continue; }
            for (int l = 0; l < 4; ++l) {
                dp[j][k][l] = 1;

                int px = j+dx[l], py = k+dy[l];
                if (0 <= px && px < N && 0 <= py && py < N) {
                    dp[j][k][l] += dp[px][py][l];
                }

                ret = max(ret, dp[j][k][l]);
            }
        }
    }

    cout << ret << endl;
    return true;
}

int main() {
    while(solve());
    return 0;
}

C++: #include <iostream>
#include <cstring>
using namespace std;
int n;
char t[256][256];
int res[4][256][256];
int d[4][2] = {
	{-1, 0},
	{-1. -1},
	{0, -1},
	{1, -1},
};
int main() {
	while (cin >> n, n) {
		for (int i = 0; i < n; i++) {
			cin >> t[i];
		}
		int result = 0;
		memset(res, 0, sizeof(res));
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < n; j++) {
				for (int k = 0; k < n; k++) {
					if ((j == 0 || k == 0 || (i == 3 && k == n - 1)) && t[j][k] == 1) {
						res[i][j][k] = 1;
					}
					else {
						int preX = k + d[i][0];
						int preY = j + d[i][1];
						if (t[j][k] == '1') {
							res[i][j][k] = res[i][preY][preX] + 1;
						}
					}
					result = max(result, res[i][j][k]);
					//cout << ' ' << result;
				}
				//cout << endl;
			}
		}
		cout << result << endl;
	}
}

C++: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main(){

	int n;
	int field[256][256];
	while(cin>>n&&n!=0){
		int maxLength=0;
		for(int i = 0; i < n; i++){
			for(int j = 0; j < n; j++){
				char ch;
				cin>>ch;
				field[i][j]=ch-'0';
			}
		}
		for(int i = 0; i < n; i++){
			int len=0;
			for(int j = 0; j < n; j++){
				if(field[i][j]==1){
					len++;
					maxLength=max(maxLength,len);
				}
				else{
					len=0;
				}
			}
		}
		for(int i = 0; i < n; i++){
			int len=0;
			for(int j = 0; j < n; j++){
				if(field[j][i]==1){
					len++;
					maxLength=max(maxLength,len);
				}
				else{
					len=0;
				}
			}
		}
		// ÈÈß
		for(int j = 0; j < 2*n-1; j++){
			int len=0;
			int cy=0;
			int cx=j;
			if(j>=n){
				cy=j-n+1;
				cx=n-1;
			}
			while(1){
				if(field[cy][cx]==1){
					len++;
					maxLength=max(maxLength,len);
				}				else{
					len=0;
				}
				int ny=cy+1;
				int nx=cx-1;
				if(!(ny>=0&&nx>=0&&ny<n&&nx<n)){
					break;
				}
				cx=nx;
				cy=ny;
			}
		}
		// ÈÈß
		for(int j = 0; j < 2*n-1; j++){
			int len=0;
			int cy=0;
			int cx=j;
			if(j>=n){
				cx=0;
				cy=j-n+1;
			}
			while(1){
				if(field[cy][cx]==1){
					len++;
					maxLength=max(maxLength,len);
				}
				else{
					len=0;
				}
				int ny=cy+1;
				int nx=cx+1;
				if(!(ny>=0&&nx>=0&&ny<n&&nx<n)){
					break;
				}
				cx=nx;
				cy=ny;
			}
		}
		cout<<maxLength<<endl;
	}


	return 0;
}