// goodwincommaderek@gmail.com
import java.util.Arrays;
import java.util.Scanner;

public class findingkeys_dg_ac {
    public static void main(String[] args) {

        // step (1/2): take in the input
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int[] arr = new int[N];
        for (int n = 0; n < N; n++) {
            arr[n] = in.nextInt();
        }

        // step (2/2): solve the problem (UwU)
        int[] str = new int[N];
        for (int n = 0; n < N; n++) {
            str[n] = arr[n] < arr[(n + 1) % N] ? 0 : 1;
        }
        SuffixArray suffixArray = new SuffixArray(str, 2);
        suffixArray.generateLCP();
        int[] ans = new int[N];
        for (int n = 0; n < N; n++) {
            int u = suffixArray.sort[n];
            int left = (n == 0) ? -2 : suffixArray.lcp[n - 1];
            int right = (n == N - 1) ? -2 : suffixArray.lcp[n];
            ans[u] = Math.max(left, right) + 1;
            if (ans[u] == 1 << suffixArray.K) {
                ans[u] = -1;
            }
        }

        StringBuilder sb = new StringBuilder();
        for (int n = 0; n < N; n++) {
            if (n > 0) sb.append('\n');
            sb.append(ans[n]);
        }
        System.out.println(sb);
    }

    static class SuffixArray {
        int N, K, Q, tie[], sort[], lcp[], st[], next[], interm[], rank[][];

        void popTheStack() {
            for (int q = Q - 1, n = N - 1; q >= 0; q--) {
                for (; st[q] != -1; n--) {
                    sort[n] = st[q];
                    st[q] = next[st[q]];
                }
            }
        }

        SuffixArray(int[] str, int radix) {
            N = str.length;
            K = 3 + (int) (Math.log(N) / Math.log(2));
            Q = Math.max(N, radix);
            tie = new int[N];
            sort = new int[N];
            next = new int[N];
            interm = new int[N];
            rank = new int[K][N];
            st = new int[Q];
            Arrays.fill(next, -1);
            Arrays.fill(st, -1);
            rank[0] = str.clone();
            for (int k = 0, o = 1; k < K - 1; k++, o += o) {
                // circular suffix array
                for (int n = 0; n < N; n++) tie[n] = rank[k][(n + o) % N];
                // radix sort
                for (int n = 0; n < N; n++) {
                    next[n] = st[tie[n]];
                    st[tie[n]] = n;
                }
                popTheStack();
                for (int n = 0; n < N; n++) interm[n] = rank[k][sort[n]];
                for (int n = 0; n < N; n++) {
                    next[sort[n]] = st[interm[n]];
                    st[interm[n]] = sort[n];
                }
                popTheStack();
                for (int n = 1, s = rank[k + 1][sort[0]]; n < N; n++) {
                    int i = sort[n - 1], j = sort[n];
                    if (rank[k][i] != rank[k][j] || tie[i] != tie[j]) s++;
                    rank[k + 1][j] = s;
                }
            }
        }

        int commonLength(int i, int j) {
            int ret = 0;
            for (int k = K - 1; k >= 0; k--) {
                if (rank[k][(i + ret) % N] == rank[k][(j + ret) % N]) {
                    ret += 1 << k;
                }
            }
            return ret;
        }

        void generateLCP() {
            lcp = new int[N - 1];
            for (int n = 0; n < N - 1; n++) lcp[n] = commonLength(sort[n], sort[n + 1]);
        }
    }
}