// #pragma GCC optimize("Ofast,unroll-loops")

#include <bits/stdc++.h>

// #pragma GCC target("avx,avx2")

using namespace std;

using ll = long long;
using ld = long double;

#define rep(i, n) for (int i = 0; i < (n); i += 1)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define len(a) ((int)(a).size())

const ll inf = 1e18;
mt19937 rnd(234);

vector<int> manacher(const string &str) {
    int n = str.size();
    std::vector<int> odd(n);
    auto &current = odd;
    for (int i = 0, l = 0, r = 0; i < n; i++) {
        if (i < r)
            current[i] = min(r - i, current[l + (r - i - 1)]);

        while (i - current[i] >= 0 && i + current[i] < n && str[i - current[i]] == str[i + current[i]]) {
            current[i]++;
        }

        if (i + current[i] > r) {
            l = i - current[i] + 1;
            r = i + current[i];
        }
    }
    return odd;
}

string remove_same(const string &s) {
    string t;
    t.reserve(len(s));
    for (auto c : s) {
        if (t.empty() or t.back() != c) {
            t.push_back(c);
        }
    }
    return t;
}

struct node {
    array<int, 26> go;
    int link;
    int ln;
};

string compress(string s) {
    string t;
    vector<node> g;
    auto new_node = [&]() -> int {
        int v = len(g);
        g.push_back(node());
        g[v].go.fill(-1);
        g[v].link = 0;
        g[v].ln = -1;
        return v;
    };
    int root = new_node();
    int cur = root;
    vector<int> nodes(len(s));
    for (auto x : s) {
        if (!t.empty() and x == t.back()) {
            continue;
        }
        t.push_back(x);
        while (cur != root and (len(t) - g[cur].ln - 2 < 0 or t[len(t) - g[cur].ln - 2] != x)) {
            cur = g[cur].link;
        }
        if (g[cur].go[x - 'a'] == -1) {
            int to = new_node();
            g[cur].go[x - 'a'] = to;
            g[to].ln = g[cur].ln + 2;
            if (g[to].ln == 1) {
                g[to].link = root;
            } else {
                int link = g[cur].link;
                while (link != root and t[len(t) - g[link].ln - 2] != x) {
                    link = g[link].link;
                }
                assert(g[link].go[x - 'a'] != -1);
                g[to].link = g[link].go[x - 'a'];
            }
        }
        cur = g[cur].go[x - 'a'];
        nodes[len(t) - 1] = cur;
        int v = cur;
        while (v != root) {
            int ln = g[v].ln;
            int i = len(t) - (ln + 1) / 2;
            int u = nodes[i];
            bool found = false;
            while (u != root) {
                if (g[u].ln == ln) {
                    found = true;
                    break;
                }
                u = g[u].link;
            }
            if (found) {
                rep(k, ln - 1) {
                    t.pop_back();
                    cur = nodes[len(t) - 1];
                }
                break;
            }
            v = g[v].link;
        }
    }
    return t;
}

string remove_start_palindrome(const string &s) {
    auto odd = manacher(s);
    int opt = 0;
    for (int i = 0; i < len(s); i += 1) {
        if (i - odd[i] + 1 <= opt) {
            opt = i;
        }
    }
    return s.substr(opt, len(s) - opt);
}

string solve(string s) {
    while (1) {
        string t = compress(s);
        // t = compress2(t);
        if (t == s) {
            break;
        }
        s = t;
    }
    string t = s;
    t = remove_start_palindrome(t);
    reverse(all(t));
    t = remove_start_palindrome(t);
    reverse(all(t));
    s = t;
    return s;
}

int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    int _;
    cin >> _;
    string s;
    cin >> s;
    string res = solve(s);
    cout << len(res) << "\n";
    cout << res << "\n";
    return 0;
}

/*
9
acwrwcwra

*/