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

using i64 = int64_t;

#define all(v) begin(v), end(v)

auto sais(const auto &s) {
    const int n = (int)s.size(), z = ranges::max(s) + 1;
    if (n == 1) return vector{0};
    vector<int> c(z); for (int x : s) ++c[x];
    partial_sum(all(c), begin(c));
    vector<int> sa(n); auto I = views::iota(0, n);
    vector<bool> t(n); t[n - 1] = true;
    for (int i = n - 2; i >= 0; --i)
        t[i] = (s[i] == s[i + 1] ? t[i + 1] : s[i] < s[i + 1]);
    auto is_lms = views::filter([&t](int x) {
        return x && t[x] && !t[x - 1]; });
    auto induce = [&] {
        for (auto x = c; int y : sa)
            if (y--) if (!t[y]) sa[x[s[y] - 1]++] = y;
        for (auto x = c; int y : sa | views::reverse)
            if (y--) if (t[y]) sa[--x[s[y]]] = y;
    };
    vector<int> lms, q(n); lms.reserve(n);
    for (auto x = c; int i : I | is_lms) {
        q[i] = int(lms.size());
        lms.push_back(sa[--x[s[i]]] = i);
    }
    induce(); vector<int> ns(lms.size());
    for (int j = -1, nz = 0; int i : sa | is_lms) {
        if (j >= 0) {
            int len = min({n - i, n - j, lms[q[i] + 1] - i});
            ns[q[i]] = nz += lexicographical_compare(begin(s) + j, begin(s) + j + len, begin(s) + i, begin(s) + i + len);
        }
        j = i;
    }
    ranges::fill(sa, 0); auto nsa = sais(ns);
    for (auto x = c; int y : nsa | views::reverse)
        y = lms[y], sa[--x[s[y]]] = y;
    return induce(), sa;
}
struct Suffix {
    int n;
    vector<int> sa, hi, rev;
    Suffix(const auto &s) : n(int(s.size())), hi(n), rev(n) {
        vector<int> _s(n + 1);
        copy(all(s), begin(_s));
        sa = sais(_s); sa.erase(sa.begin());
        for (int i = 0; i < n; ++i) rev[sa[i]] = i;
        for (int i = 0, h = 0; i < n; ++i) {
            if (!rev[i]) { h = 0; continue; }
            for (int j = sa[rev[i] - 1]; i + h < n && j + h < n && s[i + h] == s[j + h];) ++h;
            hi[rev[i]] = h ? h-- : 0;
        }
    }
};

template <int LG = 20> struct SparseTableSA : Suffix {
    array<vector<int>, LG> mn;
    SparseTableSA(const auto &s) : Suffix(s), mn{hi} {
        for (int l = 0; l + 1 < LG; l++) { mn[l + 1].resize(n);
            for (int i = 0, len = 1 << l; i + len < n; i++)
                mn[l + 1][i] = min(mn[l][i], mn[l][i + len]);
        }
    }
    int lcp(int a, int b) {
        if (a == b) return n - a;
        a = rev[a] + 1, b = rev[b] + 1;
        if (a > b) swap(a, b);
        const int lg = __lg(b - a);
        return min(mn[lg][a], mn[lg][b - (1 << lg)]);
    }
    pair<int, int> get_range(int x, int len) {
        int a = rev[x] + 1, b = rev[x] + 1;
        for (int l = LG - 1; l >= 0; l--) {
            const int s = 1 << l;
            if (a + s <= n && mn[l][a] >= len) a += s;
            if (b - s >= 0 && mn[l][b - s] >= len) b -= s;
        }
        return {b - 1, a};
    }
};

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int n;
    cin >> n;

    string S, T;
    cin >> S >> T;
    S = S + '$';
    T = '%' + T;
    ++n;

    auto rS = S, rT = T;
    reverse(all(rS));
    reverse(all(rT));

    auto F = '!' + S + '#' + T + '@';
    SparseTableSA sa('!' + S + '#' + T + '@');
    SparseTableSA rsa('!' + rS + '#' + rT + '@');

    auto OS = 1;
    auto OT = n + 2;

    for (int len = n; len >= 1; len--) {
        auto ok = [len] {
            cout << len * 2 << '\n';
            exit(0);
        };
        for (int i = 0; i + len < n; i += len) {
            int a = i, b = i + len;
            {
                int x = sa.lcp(a + OS, b + OT);
                int y = rsa.lcp(n - a + OS, n - b + OT);
                x += sa.lcp(a + x + OT, b + x + OT);
                if (x + y >= len)
                    ok();
            }
            {
                int x = sa.lcp(a + OS, b + OT);
                int y = rsa.lcp(n - a + OS, n - b + OT);
                y += rsa.lcp(n - (a - y) + OS, n - (b - y) + OS);
                if (x + y >= len)
                    ok();
            }
            {
                int x = sa.lcp(a + OT, b + OT);
                int y = rsa.lcp(n - a + OT, n - b + OT);
                y += rsa.lcp(n - (a - y) + OS, n - (b - y) + OT);
                if (x + y >= len)
                    ok();
            }
            {
                int x = sa.lcp(a + OS, b + OS);
                int y = rsa.lcp(n - a + OS, n - b + OS);
                x += sa.lcp(a + x + OS, b + x + OT);
                if (x + y >= len)
                    ok();
            }
        }
    }

    cout << 0 << '\n';
}