#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;

//#define int long long
using bll = boost::multiprecision::cpp_int;
using ll = long long;
//constexpr int INF = 1e9;//INT_MAX=(1<<31)-1=2147483647
constexpr ll INF = (ll)1e18;//(1LL<<63)-1=9223372036854775807
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr int dx[4]={1,0,-1,0};
constexpr int dy[4]={0,1,0,-1};
#ifdef LOCAL_ENV
	#define debug(var) std::cout<<#var" = "<<var<<std::endl
#else
	#define debug(var)
#endif
#define p(var) std::cout<<var<<std::endl
#define PI (acos(-1))
#define rep(i, n)   for(ll i=0, i##_length=(n); i< i##_length; ++i)
#define repeq(i, n) for(ll i=1, i##_length=(n); i<=i##_length; ++i)
#define all(v) (v).begin(), (v).end()
#define uniq(v) (v).erase(unique((v).begin(), (v).end()), (v).end());
template<typename T> inline void pv(vector<T> v) { for(ll i=0, N=v.size()-1; i<=N; i++) if(i!=N) cout << v[i] << ' '; else cout << v[i] << endl; }
template<typename T> inline T power(T x, T n){ return n ? power(x*x%MOD,n/2)*(n%2?x:1)%MOD : 1; }
template<typename T> inline T gcd(T a, T b) { return b ? gcd(b,a%b) : a; }
template<typename T> inline T lcm(T a, T b) { return a / gcd(a,  b) * b; }
template<typename T1, typename T2>inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template<typename T1, typename T2>inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {return s << "(" << p.first << ", " << p.second << ")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
	for (int i = 0, len = v.size(); i < len; ++i){
		s << v[i]; if (i < len - 1) s << "\t";
	}
	return s;
}
template<typename T> ostream& operator<<(ostream& s, const vector< vector<T> >& vv) {
	for (int i = 0, len = vv.size(); i < len; ++i){
		s << vv[i] << endl;
	}
	return s;
}
template<typename T1, typename T2> ostream& operator<<(ostream& s, const map<T1, T2>& m) {
	s << "{" << endl;
	for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr){
		s << "\t" << (*itr).first << " : " << (*itr).second << endl;
	}
	s << "}" << endl;
	return s;
}

/*-----8<-----8<-----*/

/*
RollingHash(s, mod, base):= 文字列 s のハッシュテーブルを構築する。
get(l, r):= 区間 [l,r) のハッシュ値を求める。
connect(h1, h2, h2len):= ハッシュ値 h1 と, 長さ h2len のハッシュ値 h2 を結合する。
LCP(b, l1, r1, l2, r2):= 区間 [l1,r1) と, ハッシュテーブルが b からなる区間 [l2,r2) の文字列の最長共通接頭辞の長さを求める。
*/
//using rh_type = boost::multiprecision::cpp_int;
using rh_type = unsigned long long;
class RollingHash {
public:
	rh_type mod;
	vector< rh_type > hashed, power;

	inline rh_type mul(rh_type a, rh_type b) const {
		return a * b % mod;
	}

	RollingHash(const string &s, rh_type mod = 1000000007, rh_type base = 10007) : mod(mod) {
		int sz = (int) s.size();
		hashed.assign(sz + 1, 0);
		power.assign(sz + 1, 0);
		power[0] = 1;
		for(int i = 0; i < sz; i++) {
			power[i + 1] = mul(power[i], base);
			hashed[i + 1] = mul(hashed[i], base) + s[i];
			if(hashed[i + 1] >= mod) hashed[i + 1] -= mod;
		}
	}

	rh_type get(int l, int r) const {
		rh_type ret = hashed[r] + mod - mul(hashed[l], power[r - l]);
		if(ret >= mod) ret -= mod;
		return ret;
	}

	rh_type connect(rh_type h1, int h2, int h2len) const {
		rh_type ret = mul(h1, power[h2len]) + h2;
		if(ret >= mod) ret -= mod;
		return ret;
	}

	int LCP(const RollingHash &b, int l1, int r1, int l2, int r2) {
		int len = min(r1 - l1, r2 - l2);
		int low = -1, high = len + 1;
		while(high - low > 1) {
			int mid = (low + high) / 2;
			if(get(l1, l1 + mid) == b.get(l2, l2 + mid)) low = mid;
			else high = mid;
		}
		return (low);
	}
};


signed main() {
	ll N;
	string S;
	cin>>N>>S;

	RollingHash rh(S);
	/*
	//強固にした版 boost必須です
	ll rh_mod = 100000000000000003LL;
	std::random_device rnd;
	std::mt19937 mt(rnd());
	std::uniform_int_distribution<> rand_base(2, rh_mod-2);
	ll rh_base = rand_base(mt);
	RollingHash rh(S, rh_mod, rh_base);
	*/
/*
	auto isOK=[&](ll len){
		map<bll,ll> m;
		for(ll i=0;i+len<=N;i++){
			bll hash=rh.get(i, i+len);
			if(m[hash]){
				if(i-m[hash]>=len)return true;
			}else{
				m[hash]=i;
			}
		}
		return false;
	};
*/
	auto isOK = [&](int d) -> bool {
		map<ll, ll> ma;
		for (int i = 0; i + d <= N; ++i) {
			auto p = rh.get(i, i+d);
			if (ma.count(p)) {
				if (i - ma[p] >= d) return true;
			}
			else ma[p] = i;
		}
		return false;
	};

	int left = 0, right = N/2 + 1;
	while (right - left > 1) {
		int mid = (left + right) >> 1;
		if (isOK(mid)) left = mid;
		else right = mid;
	}
	
	cout<<left<<endl;
	return 0;
}


Measured memory_bytes: 640