#include <bits/stdc++.h>

using i64 = long long;

struct DSU {
	int n;
	std::vector<int> f;

	DSU (int n_ = 0) {
		init(n_);
	}
	void init (int n_) {
		int n = n_;
		f.resize(n);
		std::iota(f.begin(), f.end(), 0);
	}

	int find (int x) {
		while (f[x] != x) {
			x = f[x] = f[f[x]];
		}
		return x;
	}
	void merge (int x, int y) {
		x = find(x);
		y = find(y);
		if (x == y) {
			return ;
		}
		f[y] = x;
	}
};

int main () {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int n;
	std::cin >> n;

	std::string s;
	std::cin >> s;

	s = ' ' + s;

	std::vector<int> v[26][26][26] {};

	for (int i = 1; i + 2 <= n; i++) {
		v[s[i] - 'a'][s[i + 1] - 'a'][s[i + 2] - 'a'].push_back(i);
	}

	DSU dsu(n + 1);
	std::vector<int> d(n + 1), use;

	auto del = [&](int x) {
		use.push_back(x);
		d[x] = 1;
		dsu.merge(x - 1, x);
	};

	int cnt = 0;
	auto find = [&](int a, int b, int c) {
		del(a);
		del(b);
		del(c);
		cnt++;
	};

	int ans = -1;
	std::array<int, 3> way = {-1, -1, -1};
	for (int i = 0; i < 26; i++) {
		for (int j = 0; j < 26; j++) {
			for (int k = 0; k < 26; k++) {
				cnt = 0;
				for (int u = 0; u < v[i][j][k].size(); u++) {
					int p = v[i][j][k][u];
					if (d[p]) {
						continue;
					}
					find(p, p + 1, p + 2);
					int np = p + 3;
					while (np <= n) {
						int c1 = dsu.find(p);
						if (c1 == 0) {
							break;
						}
						int c0 = dsu.find(c1 - 1);
						if (c0 != 0 && s[c0] - 'a' == i && s[c1] - 'a' == j && 
							s[np] - 'a' == k) {
							find(c0, c1, np);
							np++;
							continue;
						} else if (np + 1 <= n && s[c1] - 'a' == i && s[np] - 'a' == j && 
							s[np + 1] - 'a' == k) {
							find(c1, np, np + 1);
							np += 2;
							continue;
						} else {
							break;
						}
					}
				}
				if (ans < cnt) {
					ans = cnt;
					way = {i, j, k};
				}
				for (int x : use) {
					dsu.f[x] = x;
					d[x] = 0;
				}
				use.clear();
			}
		}
	}

	std::cout << ans << "\n";
	for (int i = 0; i < 3; i++) {
		std::cout << char(way[i] + 'a');
	}
	std::cout << "\n";

	return 0;
}