#include <bits/stdc++.h>

using namespace std;
using vi = vector<int>;
#define sz(c) (int)c.size()
#define all(c) c.begin(),c.end()
#define rep(i, l, r) for(int i =l;i < r;++i)

struct SuffixArray {
    vi sa, lcp;

    SuffixArray(string &s, int lim = 256) { // or basic_string<int>
        int n = sz(s) + 1, k = 0, a, b;
        vi x(all(s)), y(n), ws(max(n, lim));
        x.push_back(0), sa = lcp = y, iota(all(sa), 0);
        for (int j = 0, p = 0; p < n; j = max(1, j * 2), lim = p) {
            p = j, iota(all(y), n - j);
            rep(i, 0, n) if (sa[i] >= j) y[p++] = sa[i] - j;
            fill(all(ws), 0);
            rep(i, 0, n) ws[x[i]]++;
            rep(i, 1, lim) ws[i] += ws[i - 1];
            for (int i = n; i--;) sa[--ws[x[y[i]]]] = y[i];
            swap(x, y), p = 1, x[sa[0]] = 0;
            rep(i, 1, n) a = sa[i - 1], b = sa[i], x[b] =
                        (y[a] == y[b] && y[a + j] == y[b + j]) ? p - 1 : p++;
        }
        for (int i = 0, j; i < n - 1; lcp[x[i++]] = k)
            for (k &&k--, j = sa[x[i] - 1];
                    s[i + k] == s[j + k];
        k++);
    }
};

constexpr int LOG = 20;

int main() {
    cin.tie(0)->sync_with_stdio(false);
    int n;
    cin >> n;
    string s, t;
    cin >> s >> t;
    int res = 0;
    auto solve = [&] {
        string q = s;
        q += 'z' + 1;
        q += t;
        q += 'z' + 2;
        q += string(s.rbegin(), s.rend());
        q += 'z' + 3;
        q += string(t.rbegin(), t.rend());
        auto SA = SuffixArray(q);
        vector<vector<int>> sp(LOG);
        int N = SA.sa.size();
        sp[0] = SA.lcp;
        for (int i = 1; i < LOG; ++i) {
            sp[i].resize(N);
            for (int j = 0; j + (1 << i) - 1 < sp[i].size(); ++j) {
                sp[i][j] = min(sp[i - 1][j], sp[i - 1][j + (1 << (i - 1))]);
            }
        }
        vector<int> pos(N);
        for (int i = 0; i < N; ++i) {
            pos[SA.sa[i]] = i;
        }
        auto ask = [&](int l, int r) {
            if (l >= r)return 0;
            int len = r - l;
            int lg = __lg(len);
            return min(sp[lg][l], sp[lg][r - (1 << lg)]);
        };
        auto lcp = [&](int x, int y) {
            x = pos[x], y = pos[y];
            if (x > y)swap(x, y);
            if (x < 0 || y > N)return 0;
            return ask(x + 1, y + 1);
        };
        auto rev = [&](int i) {
            return n - i - 1;
        };
        for (int l = 1; l <= n; ++l) {
            for (int i = 0; i + l - 1 < n; i += l) {
                // stupid
                {
                    int lq = i, rq = i + l - 1;
                    rq += lcp(i, i + l);
                    lq -= lcp(rev(i + l - 1) + 2 * (n + 1), rev(i - 1) + 2 * (n + 1));
                    if (rq - lq + 1 >= 2 * l) {
                        res = max(res, l);
                        continue;
                    }
                    rq += lcp(i + (rq + 1) % l, rq + 1 + (n + 1) - 1);
                    if (rq - lq + 1 >= 2 * l) {
                        res = max(res, l);
                    }
                }
                {
                    int pf = lcp(i, i + l + (n + 1) - 1);
                    int sf = lcp(rev(i - 1) + 2 * (n + 1), rev(i + l - 1 - 1) + 3 * (n + 1));
                    if (pf + sf >= l) {
                        res = max(res, l);
                        continue;
                    }
                    int need = l - pf - sf;
                    if (lcp(rev(i + l - 1 - sf) + 2 * (n + 1), rev(i - 1 - sf) + 2 * (n + 1)) >= need)res = max(res, l);
                    if (lcp(i + pf + (n + 1) - 1, i + l + pf + (n + 1) - 1) >= need)res = max(res, l);
                }
            }
        }
    };
    solve();
    swap(s, t);
    reverse(s.begin(), s.end());
    reverse(t.begin(), t.end());
    solve();
    cout << res * 2;
}