#include <bits/stdc++.h>

using i64 = int64_t;
template <typename T>
using minpq = std::priority_queue<T, std::vector<T>, std::greater<T>>;

i64 gcd(i64 a, i64 b) {
    return b ? gcd(b, a % b) : a;
}
i64 lcm(i64 a, i64 b) {
    return a / gcd(a, b) * b;
}

struct System {
    int P;
    std::vector<uint8_t> v;
};

System merge(const System &a, const System &b) {
    System r;
    r.P = lcm(a.P, b.P);
    r.v.resize(r.P);
    for (int i = 0; i < r.P; ++i) {
        r.v[i] = a.v[i % a.P] && b.v[i % b.P];
    }
    return r;
}

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

    int n;
    std::cin >> n;

    std::vector<System> syss;

    std::string pattern = "TTPC";
    for (int i = 0; i < 4; ++i) {
        std::string s;
        std::cin >> s;
        System sys;
        sys.P = s.size();
        sys.v.resize(sys.P);
        for (int j = 0; j < s.size(); ++j) {
            if (s[j] == pattern[i]) {
                sys.v[j] = true;
            }
        }
        syss.push_back(sys);
    }

    System A = merge(syss[0], syss[1]), B = merge(syss[2], syss[3]);

    std::vector<int> leap(B.P, -1);
    for (int i = 0; i < B.P; ++i) {
        if (B.v[i]) {
            leap[i] = 0;
        }
    }
    for (int i = 0; i < B.P; ++i) {
        if (B.v[i]) {
            for (int j = 1; ; ++j) {
                int p = ((i - (i64)j * A.P) % B.P + B.P) % B.P;
                if (leap[p] != -1) {
                    break;
                }
                leap[p] = j;
            }
        }
    }

    // A * p + a
    // pair of p, a

    auto get_b = [&](i64 p, i64 a) -> i64 {
        return (((i64)A.P * p + a) % B.P + B.P) % B.P;
    };

    minpq<std::pair<i64, i64>> q;
    for (int i = 0; i < A.P; ++i) {
        if (A.v[i]) {
            i64 a = i, p = 0;

            i64 b = get_b(p, a);
            p += leap[b];

            if (p != -1) {
                q.emplace(p, a);
            }
        }
    }
    if (q.empty()) {
        std::cout << "-1\n";
        return 0;
    }

    for (int i = 0; i < n - 1; ++i) {
        auto [p, a] = q.top();
        q.pop();

        ++p;
        i64 b = get_b(p, a);
        p += leap[b];
        q.emplace(p, a);
    }

    auto [p, a] = q.top();
    std::cout << (i64)A.P * p + a + 1 << '\n';
}