#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;


vector<bool> combine(vector<bool>& first, vector<bool>& second) {
    int n = first.size();
    int m = second.size();
    vector<bool> ans(n * m);
    for (int i = 0; i < n * m; ++i)
        ans[i] = first[i % n] && second[i % m];
    return ans;
}

const long long INF = 1e18 + 228;


long long safe_add(long long x, long long y) {
    return min(x + y, INF);
}

long long safe_mul(long long x, long long y) {
    if (y == 0)
        return 0;
    if (x <= INF / y)
        return x * y;
    return INF;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int N;
    cin >> N;
    vector<string> lines(4);
    for (int i = 0; i < 4; ++i)
        cin >> lines[i];
    vector<bool> good[4];
    char interesting[4] = {'T', 'T', 'P', 'C'};
    for (int i = 0; i < 4; ++i) {
        good[i].resize(lines[i].size());
        for (int j = 0; j < lines[i].size(); ++j)
            good[i][j] = (lines[i][j] == interesting[i]);
    }

    auto A = combine(good[0], good[1]);
    auto B = combine(good[2], good[3]);
    int n = A.size();
    int m = B.size();
    vector<int> go(m);
    for (int i = 0; i < m; ++i)
        go[i] = (i + n) % m;
    vector<int> order;
    vector<bool> used(m);
    vector<int> cycle_st(m);
    vector<int> cycle_end(m);
    for (int i = 0; i < m; ++i) {
        if (used[i]) {
            continue;
        }
        int st = order.size();
        int cur = i;
        while (!used[cur]) {
            used[cur] = true;
            order.emplace_back(cur);
            cur = go[cur];
        }
        for (int j = st; j < order.size(); ++j) {
            cycle_st[order[j]] = st;
            cycle_end[order[j]] = order.size();
        }
    }
    vector<int> id(m);
    for (int i = 0; i < m; ++i)
        id[order[i]] = i;
    vector<int> pref_sum(m + 1);
    for (int i = 0; i < m; ++i)
        pref_sum[i + 1] = pref_sum[i] + B[order[i]];
    long long left = -1, right = INF;
    while (right - left > 1) {
        long long mid = (left + right) / 2;
        long long cnt = 0;
        for (int i = 0; i < n; ++i) {
            if (!A[i])
                continue;
            if (mid < i)
                continue;
            long long mx = (mid - i) / n;
            // i, i + n ... i + mx * n
            int val = i % m;
            int st = cycle_st[val];
            int end = cycle_end[val];
            int j = id[val];
            int cycle_sz = end - st;
            int cycle_sum = pref_sum[end] - pref_sum[st];
            long long steps = mx / cycle_sz;
            cnt = safe_add(cnt, safe_mul(steps, cycle_sum));
            mx -= steps * cycle_sz;
            int fin = j + mx + 1;
            if (fin > end) {
                fin = fin + st - end;
                cnt = safe_add(cnt, cycle_sum - pref_sum[j] + pref_sum[fin]);
            } else {
                cnt = safe_add(cnt, pref_sum[fin] - pref_sum[j]);
            }
        }
        if (cnt >= N)
            right = mid;
        else
            left = mid;
    }
    if (right == INF)
        right = -2;
    cout << right + 1 << '\n';
    return 0;
}