#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

// Hàm băm đơn giản (dùng cho minh hoạ, thực tế cần double hash)
struct Hasher {
    vector<long long> h, p;
    long long base = 31, mod = 1e9 + 7;
    Hasher(string s) {
        int n = s.size();
        h.resize(n + 1); p.resize(n + 1);
        p[0] = 1;
        for (int i = 0; i < n; ++i) {
            h[i + 1] = (h[i] * base + (s[i] - 'a' + 1)) % mod;
            p[i + 1] = (p[i] * base) % mod;
        }
    }
    long long get(int l, int r) { // [l, r)
        return (h[r] - h[l] * p[r - l] % mod + mod) % mod;
    }
};

int main() {
    int k;
    cin >> k;
    string s;
    cin >> s;

    long long total_len = 0;

    // Với mỗi tiền tố
    for (int len = 1; len <= k; ++len) {
        string P = s.substr(0, len);
        // Tìm border dài nhất
        // Cần tính Z-function hoặc Prefix Function để lấy border
        // Ở đây ta dùng cách brute force tìm border
        int max_cycle_len = 0;

        // Tìm chu kỳ cơ sở (độ dài lặp)
        int period = len;
        for (int i = 1; i <= len/2; ++i) {
            if (len % i == 0) {
                bool ok = true;
                for (int j = 0; j < len; ++j) {
                    if (P[j] != P[j % i]) { ok = false; break; }
                }
                if (ok) { period = i; break; }
            }
        }

        // Kiểm tra border
        for (int b = len - 1; b >= 1; --b) {
            // Kiểm tra b có phải border không
            bool is_border = true;
            for (int i = 0; i < b; ++i) {
                if (P[i] != P[len - b + i]) { is_border = false; break; }
            }
            if (is_border) {
                if (b % period == 0) {
                    max_cycle_len = b;
                    break;
                }
            }
        }
        total_len += max_cycle_len;
    }
    cout << total_len << endl;
    return 0;
}

#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main() {
    int k;
    if (!(cin >> k)) return 0;
    string s;
    cin >> s;

    vector<int> pi(k, 0);
    vector<int> min_border(k, 0);

    // Tính Prefix Function (pi)
    for (int i = 1; i < k; ++i) {
        int j = pi[i - 1];
        while (j > 0 && s[i] != s[j]) {
            j = pi[j - 1];
        }
        if (s[i] == s[j]) ++j;
        pi[i] = j;
    }

    // Tính min_border: độ dài border nhỏ nhất (khác rỗng) của mỗi tiền tố
    for (int i = 0; i < k; ++i) {
        if (pi[i] == 0) {
            min_border[i] = 0;
        } else {
            // Nếu pi[pi[i]-1] == 0, thì pi[i] là border nhỏ nhất
            if (pi[pi[i] - 1] == 0) {
                min_border[i] = pi[i];
            } else {
                min_border[i] = min_border[pi[i] - 1];
            }
        }
    }

    long long result = 0;
    for (int i = 0; i < k; ++i) {
        int L = i + 1;
        int t = min_border[i];
        if (t > 0) {
            // Chu kỳ dài nhất có độ dài L - t
            result += (L - t);
        }
    }

    cout << result << "\n";
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int n, Pi[1000007], K[1000007];
long long res;
string s;

int main() {
    cin >> n >> s;
    s = " " + s;
    int j = 0;
    // Tính Pi
    for (int i = 2; i <= n; i++) {
        while (j != 0 && s[i] != s[j + 1]) j = Pi[j];
        if (s[i] == s[j + 1]) j++;
        Pi[i] = j;
    }
    // Tối ưu Pi (Path compression)
    // Biến Pi[i] thành độ dài border 'gần nhất' có tính chất periodic
    // Tuy nhiên, code gốc có vẻ tối ưu theo cách khác để lấy K[i]
    // Code gốc:
    // for (int i = 1; i <= n; i++) if (Pi[Pi[i]] != 0) Pi[i] = Pi[Pi[i]];
    // Đoạn này thực chất là gom các border.

    // Tính K[i] là độ dài border nhỏ nhất (hoặc chu kỳ cơ sở)
    // Code gốc:
    // for (int i = 1; i <= n; i++)
    //     if (Pi[i] != 0) K[i] = i - Pi[i]; // Gốc là K[i] = i - Pi[i]?
    // Không, code gốc chỉ cộng dồn kết quả.

    // Phân tích code gốc:
    // for (int i = 1; i <= n; i++)
    //     if (Pi[i] != 0)
    //         res += i - Pi[i];
    // 
    // Nhưng trước đó có:
    // if (Pi[Pi[i]] != 0) Pi[i] = Pi[Pi[i]];
    // 
    // Ví dụ: P = 'bababa'. Pi[6] = 4. Pi[4] = 2. Pi[2] = 0.
    // i=6: Pi[6]=4, Pi[4]=2 != 0 => Pi[6] = 2.
    // res += 6 - 2 = 4. (Đúng)
    // 
    // Ví dụ: P = 'abcabc'. Pi[6]=3. Pi[3]=0.
    // i=6: Pi[6]=3, Pi[3]=0 => Pi[6] remains 3.
    // res += 6 - 3 = 3. (Đúng)
    // 
    // Ví dụ: P = 'ababa'. Pi[5]=3. Pi[3]=1. Pi[1]=0.
    // i=5: Pi[5]=3, Pi[3]=1 != 0 => Pi[5] = 1.
    // res += 5 - 1 = 4. (Chu kỳ dài nhất là 'ababa' - 'a' = 'abab'? Sai.
    // Chu kỳ dài nhất của 'ababa' là 'aba' - 'a' = 'ab'. Độ dài 2.
    // Đợi đã, 'ababa' có border 'aba' (len 3). Chu kỳ cơ sở 'ab' (len 2).
    // Border có độ dài chia hết cho 2 là 'aba' (len 3) không chia hết? Không.
    // 'aba' là border duy nhất. Chu kỳ cơ sở là 'ab' (len 2).
    // Border phải chia hết cho 2. Không có border chia hết cho 2 (trừ rỗng).
    // Chu kỳ dài nhất rỗng, độ dài 0.
    // Code tính 5 - 1 = 4. Sai.
    // 
    // Wait, lại xem lại định nghĩa.
    // 'ababa'. Chu kỳ cơ sở là 'ab'.
    // Border: 'aba' (3). 3 chia hết cho 2? Không.
    // Border: '' (0).
    // Chu kỳ dài nhất: ''.
    // 
    // Xem lại Solution 3.
    // for (int i = 1; i <= n; i++) if (Pi[Pi[i]] != 0) Pi[i] = Pi[Pi[i]];
    // for (int i = 1; i <= n; i++) if (Pi[i] != 0) res += i - Pi[i];

    // Lại thử VD: 'bababa' (n=6)
    // Pi[1]=0, Pi[2]=1 ('b'), Pi[3]=0 ('bab'), Pi[4]=3 ('baba'), Pi[5]=2 ('babab'), Pi[6]=4 ('bababa')
    // Loop i=1..6:
    // i=1: Pi[1]=0. Skip.
    // i=2: Pi[2]=1. Pi[1]=0. Skip. Res += 2-1=1. (Sai, phải là 2)
    // i=3: Pi[3]=0. Skip.
    // i=4: Pi[4]=3. Pi[3]=0. Skip. Res += 4-3=1. (Sai)
    // i=5: Pi[5]=2. Pi[2]=1 != 0. Pi[5] = Pi[2] = 1. Res += 5-1=4. (Sai)
    // i=6: Pi[6]=4. Pi[4]=3 != 0. Pi[6] = Pi[4] = 3. Res += 6-3=3. (Sai)
    // Sum = 1+1+4+3 = 9. Output mẫu là 24.
    // Có lẽ code trong file zip bị thiếu hoặc khác.

    // Tuy nhiên, Approach 2 là chính xác và dễ hiểu nhất.
    // Approach này là biến thể của KMP với path compression để tìm độ dài border đặc biệt.
    // Dưới đây là code đã được sửa lại dựa trên logic của Solution 2 (minBorder)

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

    int main() {
        ios::sync_with_stdio(false);
        cin.tie(nullptr);
        int k;
        string s;
        if (!(cin >> k)) return 0;
        cin >> s;
        vector<int> pi(k, 0);
        vector<int> minBorder(k, 0);
        for (int i = 1; i < k; ++i) {
            int j = pi[i - 1];
            while (j > 0 && s[i] != s[j]) j = pi[j - 1];
            if (s[i] == s[j]) ++j;
            pi[i] = j;
            if (pi[i] == 0) minBorder[i] = 0;
            else {
                if (pi[pi[i] - 1] == 0) minBorder[i] = pi[i];
                else minBorder[i] = minBorder[pi[i] - 1];
            }
        }
        long long result = 0;
        for (int i = 0; i < k; ++i) {
            int L = i + 1;
            int t = minBorder[i];
            if (t > 0) result += (L - t);
        }
        cout << result << "\n";
        return 0;
    }