#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

inline bool Good(const vector<int>& v) {
    for (int i = 1; i < (int)v.size(); i++) {
        if (v[i] != i) {
            return false;
        }
    }
    return true;
}

inline void Sort(vector<int>& v, int l, int r) {
    sort(v.begin() + l, v.begin() + r + 1);
}

void Small(vector<int> p, int n, ostream& cout) {
    if (Good(p)) {
        cout << "." << endl;
        exit(0);
    }

    auto Check = [&](int len) -> pair<bool, int> {
        if (len + len + 1 > n) return {true, -1};

        auto temp = p;
        Sort(temp, 1, len);
        Sort(temp, n - len, n);
        if (Good(temp)) {
            return {true, 0};
        }

        temp = p;
        Sort(temp, 1, len + 1);
        Sort(temp, n - len + 1, n);
        if (Good(temp)) {
            return {true, 1};
        }

        return {false, -1};
    };

    int result = -1;
    for (int step = 1 << 20; step; step >>= 1) {
        if (!Check(result + step).first) {
            result += step;
        }
    }

    result++;
    auto curr = Check(result);

    if (result + result + 1 <= n && curr.first) {
        string str;
        for (int i = 1; i <= result + 1; i++) {
            if ((result % 2 == 1 && curr.second == 0) || (result % 2 == 0 && curr.second == 1)) {
                str += (i % 2 == 1 ? 'P' : 'S');
            } else {
                str += (i % 2 == 1 ? 'S' : 'P');
            }
        }
        cout << str << "." << endl;
        exit(0);
    }
}

int Big(vector<int> p, int n, bool isPref) {
    if (!isPref) {
        for (int i = 1; i <= n; i++) {
            p[i] = n - p[i] + 1;
        }
        reverse(p.begin() + 1, p.end());
    }

    int len = 1;
    while (len + (len + 1) <= n) {
        len++;
    }

    if (len % 2) {
        Sort(p, 1, len);
        Sort(p, n - len, n);
    } else {
        Sort(p, 1, len + 1);
        Sort(p, n - len + 1, n);
    }

    int pref = 0;
    while (p[pref + 1] == pref + 1) {
        pref++;
    }

    int suff = 0;
    while (p[n - suff] == n - suff) {
        suff++;
    }

    if (pref + suff >= n) {
        return len + 1;
    }

    pair<int, int> half1 = {pref + 1, pref + 1};
    while (p[half1.second] < p[half1.second + 1]) {
        half1.second++;
    }

    pair<int, int> half2 = {n - suff, n - suff}; 
    while (p[half2.first - 1] < p[half2.first]) {
        half2.first--;
    }

    auto temp = p;
    
    len++;
    while (true) {
        len++;
        assert (len <= n);

        // for (int i = 1; i <= n; i++) {
        //     cerr << temp[i] << " ";
        // }
        // cerr << "\n LEN = " << len << "\n";
        // cerr << pref << " (" << half1.first << ", " << half1.second << ")\n";
        // cerr << suff << " (" << half2.first << ", " << half2.second << ")\n";

        if (len & 1) {
            int l = half1.first;
            int r = half2.first;
            int maxr = half2.first + (len - pref - (half1.second - half1.first + 1));
            // cerr << "MAXR: " << maxr << "\n";

            while (l <= half1.second || r < maxr) {
                // cerr << "L, R, PREF --> " << l << " " << r << " " << pref << "\n";
                if (p[l] < p[r]) {
                    if (l <= half1.second && p[l] == pref + 1) {
                        half1.first++;
                        l++;
                    } else {
                        break;
                    }
                } else {
                    if (r < maxr && p[r] == pref + 1) {
                        half2.first++;
                        r++;
                    } else {
                        break;
                    }
                }
                pref++;
            }

            #ifdef HOME
                Sort(temp, 1, len);
            #endif
        } else {
            int l = half1.second;
            int r = half2.second;
            int minl = half1.second - (len - suff - (half2.second - half2.first + 1));

            while (r >= half2.first || l > minl) {
                if (p[l] > p[r]) {
                    if (l > minl && p[l] == n - suff) {
                        half1.second--;
                        l--;
                    } else {
                        break;
                    }
                } else {
                    if (r >= half2.first && p[r] == n - suff) {
                        half2.second--;
                        r--;
                    } else {
                        break;
                    }
                }
                suff++;
            }

            #ifdef HOME
                Sort(temp, n - len + 1, n);
            #endif
        }

        if (pref + suff >= n) {
            #ifdef HOME
                cerr << "!!!";
                for (auto itr : temp) {
                    cerr << itr << " ";
                }
                cerr << "\n";
            #endif
            return len;
        }
    }
}

int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int n;
    cin >> n;

    vector<int> p(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> p[i];
    }

    Small(p, n, cout);

    auto res1 = Big(p, n, true);
    auto res2 = Big(p, n, false);
    string str;

    if (res1 < res2) {
        for (int i = 0; i < res1; i++) {
            if (i % 2 == 0) {
                str += 'P';
            } else {
                str += 'S';
            }
        }
    } else {
        for (int i = 0; i < res2; i++) {
            if (i % 2 == 1) {
                str += 'P';
            } else {
                str += 'S';
            }
        }
    }

    cout << str << ".";

    return 0;
}