#include <algorithm>
#include <array>
#include <bitset>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>

#include <cassert>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>

using namespace std;

#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)

#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif

template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
    os << "{";
    for (auto it = v.begin(); it != v.end(); ++it) {
        if (it != v.begin())
            os << ",";
        os << *it;
    }
    return os << "}";
}

template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& v)
{
    os << "{";
    os << v.first << ", " << v.second;
    return os << "}";
}

// ---------------------------------------------------------------------------

using point = complex<double>;
using ll = long long;
//
//struct Tri {
//    unordered_map<char, Tri*> next;
//    int mini = 1000000;
//    int maxi = -1;
//};
//
//int solve(Tri* s, int depth)
//{
//    int ret = 0;
//    if (s->mini + depth <= s->maxi)
//        ret = depth;
//
//    for (const auto& p : s->next)
//        ret = max(ret, solve(p.second, depth+1));
//
//    return ret;
//}
//
//int my_main(int argc, char** argv)
//{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
//
//    int n;
//    cin >> n;
//    string s;
//    cin >> s;
//
//    int ret = 0;
//    Tri* eps = new Tri();
//    for (int i = 0; i < n; i++) {
//        Tri* cur = eps;
//        int depth = 0;
//        for (int j = 0; j <= n / 2 && i + j < n; j++) {
//            char c = s[i+j];
//            auto it = cur->next.find(c);
//            Tri* nex;
//            if (it == cur->next.end()) {
//                nex = cur->next[c] = new Tri();
//                nex->mini = i;
//            } else {
//                nex = it->second;
//            }
//            cur = nex;
//            cur->maxi = max(cur->maxi, i);
//            //cur->mini = min(cur->mini, i);
//
//            //if (cur->mini + depth <= cur->maxi) {
//            //    ret = max(ret, depth);
//            //}
//            //depth++;
//        }
//    }
//
//    cout << solve(eps, 0) << endl;
//    return 0;
//}

//struct Tri {
//    vector<Tri*> next;
//    char c;
//    int mini = 1000000;
//    int maxi = -1;
//};
//
//int solve(Tri* s, int depth)
//{
//    int ret = 0;
//    if (s->mini + depth <= s->maxi)
//        ret = depth;
//
//    for (const auto& p : s->next)
//        ret = max(ret, solve(p, depth+1));
//
//    return ret;
//}
//int my_main(int argc, char** argv)
//{
//    ios::sync_with_stdio(false);
//    cin.tie(0);
//
//    int n;
//    cin >> n;
//    string s;
//    cin >> s;
//
//    int ret = 0;
//    Tri* eps = new Tri();
//    eps->c = 0;
//
//    for (int i = 0; i < n; i++) {
//        Tri* cur = eps;
//        int depth = 0;
//        for (int j = 0; j <= n / 2 && i + j < n; j++) {
//            char c = s[i + j];
//            Tri* nex = nullptr;
//            for (Tri* t : cur->next) {
//                if (t->c == c) {
//                    nex = t;
//                    break;
//                }
//            }
//            if (nex == nullptr) {
//                nex = new Tri();
//                nex->c = c;
//                cur->next.push_back(nex);
//                nex->mini = i;
//            }
//            cur = nex;
//            cur->maxi = max(cur->maxi, i);
//        }
//    }
//
//    cout << solve(eps, 0) << endl;
//    return 0;
//}


// z-algorithm (O(|S|)
// Return V where V[i] = length of the largest common prefix of S and S[i] 
// Example:
//  S: aaabaaaab
//  V: 921034210
//vector<int> zAlgorithm(const std::string& s)
//{
//    std::vector<int> ret(s.size());
//    ret[0] = s.size();
//
//    int i = 1, j = 0;
//    while (i < s.size()) {
//        while (i + j < s.size() && s[j] == s[i + j])
//            j++;
//
//        ret[i] = j;
//        if (j == 0) {
//            i++;
//            continue;
//        }
//
//        int k = 1;
//        while (i + k < s.size() && k + ret[k] < j) {
//            ret[i + k] = ret[k];
//            k++;
//        }
//
//        i += k;
//        j -= k;
//    }
//
//    return ret;
//}

vector<int> zAlgorithm(const std::string& s)
{
    std::vector<int> z(s.size());
    z[0] = s.size();

    // left-bound, right-bound of current z-box.
    int lt = 0, rt = 0;

    for (int k = 1; k < s.size(); k++) {
        if (k > rt) {
            // If k is outside the current z-box, then we do naive computation.
            int n = 0;
            while (n + k < s.size() && s[n] == s[n + k])
                n++;
            z[k] = n;
            if (n > 0) {
                lt = k;
                rt = k + n - 1;
            }
        } else {
            // If k is inside the current z-box, then consider two cases
            int p = k - lt; // pair index
            // rightPartLen is a length of k..rt 
            int rightPartLen = rt - k + 1;

            if (z[p] < rightPartLen) {
                z[k] = z[p];
            } else {
                // s[i - k] is a A[i] where A starts from k of S.
                int i = rt + 1;
                while (i < s.size() && s[i] == s[i - k])
                    i++;
                z[k] = i - k;
                lt = k;
                rt = i - 1;
            }
        }
    }
    return z;
}

int my_main(int argc, char** argv)
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;
    string s;
    cin >> s;

    int ret = 0;
    for (int i = 0; i < n; i++) {
        const auto ss = s.substr(i);
        const auto v = zAlgorithm(ss);

        for (int j = 0; j < v.size(); j++) {
            if (v[j] <= j)
                ret = max(ret, v[j]);
        }
    }

    cout << ret << endl;

    return 0;
}

// ----------------------------------------------------------------------------
// Test driver

#ifdef DEBUG
#define MAY_RUN_TESTCASE
#endif

#ifdef MAY_RUN_TESTCASE
#include <fstream>

#if __has_include(<unistd.h>)
// Mac, Linux
#include <unistd.h>
#elif __has_include(<io.h>)
// Windows
#include <io.h>
#else
// Other?
#error "unistd.h or io.h not found"
#endif

bool test_file_exists(const std::string& str)
{
    std::ifstream fs(str);
    return fs.is_open();
}

#endif

int main(int argc, char** argv)
{
#ifndef MAY_RUN_TESTCASE
    return my_main(argc, argv);
#else
    if (argc == 1) {
        return my_main(argc, argv);
    } else if (argc == 2) {

        char* stdin_file = argv[1];
        freopen(stdin_file, "r", stdin);
        return my_main(argc, argv);

    } else if (argc == 5) {

        std::string stdin_file = argv[1];
        std::string expected_file = argv[2];
        std::string stdout_file = argv[3];
        std::string stderr_file = argv[4];

        if (!test_file_exists(stdin_file)) {
            std::cerr << stdin_file << " not found" << std::endl;
            return 3;
        }

        if (!test_file_exists(expected_file)) {
            std::cerr << expected_file << " not found" << std::endl;
            return 3;
        }

        int original_stdin = dup(fileno(stdin));
        int original_stdout = dup(fileno(stdout));
        int original_stderr = dup(fileno(stderr));

        freopen(stdin_file.c_str(), "r", stdin);
        freopen(stdout_file.c_str(), "w", stdout);
        freopen(stderr_file.c_str(), "w", stderr);

        int ret = my_main(argc, argv);

        fflush(stdout);
        fflush(stderr);

        dup2(original_stderr, fileno(stderr));
        dup2(original_stdout, fileno(stdout));
        dup2(original_stdin, fileno(stdin));

        if (ret != 0) {
            std::cerr << "main returns " << ret << std::endl;
            return ret;
        }

        std::ifstream inp(stdin_file);
        std::ifstream out(stdout_file);
        std::ifstream err(stderr_file);
        std::ifstream exp(expected_file);

        // Clear is needed if the file is empty.
        std::cout << "----- input -----" << std::endl;
        std::cout << inp.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl
                  << std::endl;

        std::cout << "----- output ----" << std::endl;
        std::cout << out.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl
                  << std::endl;

        std::cout << "---- expected ---" << std::endl;
        std::cout << exp.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl
                  << std::endl;

        std::cout << "----- stderr ----" << std::endl;
        std::cout << err.rdbuf() << std::endl;
        std::cout.clear();
        std::cout << "-----------------" << std::endl;

        inp.seekg(0);
        out.seekg(0);
        exp.seekg(0);
        err.seekg(0);

        std::string output_str, expected_str;
        {
            std::stringstream output_ss;
            output_ss << out.rdbuf();
            output_str = output_ss.str();

            std::stringstream expected_ss;
            expected_ss << exp.rdbuf();
            expected_str = expected_ss.str();
        }

        // Remove trailing spaces
        output_str.erase(output_str.find_last_not_of(" \n\r\t") + 1);
        expected_str.erase(expected_str.find_last_not_of(" \n\r\t") + 1);

        if (output_str == expected_str)
            return 0;
        else
            return 1;
    }
    return 1;
#endif
}


Measured memory_bytes: 256