import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.OutputStream;

class Kattio extends PrintWriter {
    public Kattio(InputStream i) {
        super(new BufferedOutputStream(System.out));
        r = new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(InputStream i, OutputStream o) {
        super(new BufferedOutputStream(o));
        r = new BufferedReader(new InputStreamReader(i));
    }

    public boolean hasMoreTokens() {
        return peekToken() != null;
    }

    public int getInt() {
        return Integer.parseInt(nextToken());
    }

    public double getDouble() { 
        return Double.parseDouble(nextToken());
    }

    public long getLong() {
        return Long.parseLong(nextToken());
    }

    public String getWord() {
        return nextToken();
    }



    private BufferedReader r;
    private String line;
    private StringTokenizer st;
    private String token;

    private String peekToken() {
	if (token == null) 
	    try {
            while (st == null || !st.hasMoreTokens()) {
                line = r.readLine();
                if (line == null) return null;
                st = new StringTokenizer(line);
            }
		token = st.nextToken();
	    } catch (IOException e) { }
        return token;
    }

    private String nextToken() {
        String ans = peekToken();
        token = null;
        return ans;
    }
}

class RMQ {
  int[][] jmp;
  public RMQ(int[] V) {
    int n = V.length;
    jmp = new int[20][n];
    for (int i = 0; i<n; i++) {
      jmp[0][i] = V[i];
    }
    for (int pw = 1, k = 1; pw * 2 <= n; pw *= 2, k++) {
      for (int j = 0; j<n - pw * 2 + 1; j++) {
        jmp[k][j] = Math.min(jmp[k-1][j], jmp[k-1][j+pw]);
      }
    }
  }
  int query(int a, int b) {
    int dep = 31 - Integer.numberOfLeadingZeros(b-a);
    return Math.min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
  }
}

class SuffixArray {
  public SuffixArray(String s) {
    buildSuffixArray(s + "$");
    buildLcpArray(s + "$");
  }
  private void buildSuffixArray(String s) {
    int n = s.length();
    int alphabet = 256;
    sa = new int[n];
    int[] c = new int[n];
    int[] cnt = new int[Math.max(alphabet, n)];
    for (int i = 0; i<n; i++) {
      cnt[s.charAt(i)]++;
    }
    for (int i = 1; i < alphabet; i++) {
      cnt[i] += cnt[i-1];
    }
    for (int i = 0; i<n; i++) {
      sa[--cnt[s.charAt(i)]] = i;
    }
    c[sa[0]] = 0;
    int classes = 1;
    for (int i = 1; i<n; i++) {
      if (s.charAt(sa[i]) != s.charAt(sa[i-1])) {
        classes++;
      }
      c[sa[i]] = classes - 1;
    }
    int[] pn = new int[n], cn = new int[n];
    for (int h = 0; (1 << h) < n; h++) {
      for (int i = 0; i<n; i++) {
        pn[i] = sa[i] - (1 << h);
        if (pn[i] < 0) pn[i] += n;
      }
      for (int i = 0; i<classes; i++) {
        cnt[i] = 0;
      }
      for (int i = 0; i<n; i++) {
        cnt[c[pn[i]]]++;
      }
      for (int i =1; i<classes; i++) {
        cnt[i] += cnt[i-1];
      }
      for (int i = n-1; i>=0; i--) {
        sa[--cnt[c[pn[i]]]] = pn[i];
      }
      cn[sa[0]] = 0;
      classes = 1;
      for (int i =1 ; i<n; i++) {
        if (c[sa[i]] != c[sa[i-1]] || (c[sa[i]] == c[sa[i-1]] && c[(sa[i] + (1 << h)) % n] != c[(sa[i-1] + (1 << h)) % n])) {
          classes++;
        }
        cn[sa[i]] = classes-1;
      }
      for (int i = 0; i<n; i++) {
        int temp = c[i];
        c[i] = cn[i];
        cn[i] = temp;
      }
    }
    pos = new int[sa.length];
    for (int i = 0; i<sa.length; i++) {
      pos[sa[i]] = i;
    }
  }
  private void buildLcpArray(String s) {
    int n = s.length();
    int[] rank = new int[n];
    for (int i = 0; i<n; i++) {
      rank[sa[i]] = i;
    }
    int k = 0;
    lcp = new int[n-1];
    for (int i = 0; i<n; i++) {
      if (rank[i] == n-1) {
        k = 0;
        continue;
      }
      int j = sa[rank[i] + 1];
      while (i + k < n && j + k < n && s.charAt(i+k) == s.charAt(j+k)) k++;
      lcp[rank[i]] = k;
      if (k != 0) k--;
    }
    rmqLcp = new RMQ(lcp);
  }
  public int queryLcp(int i, int j) {
    return rmqLcp.query(i, j);
  }
  int[] sa, lcp, pos;
  RMQ rmqLcp;
}

public class FindingKeys {
    public static void main(String[] args) {
        Kattio io = new Kattio(System.in, System.out);
        int n = io.getInt();
        int[] a = new int[n];
        for (int i = 0; i<n; i++) {
            a[i] = io.getInt();
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i<n*2; i++) {
            if (a[i % n] < a[(i+1) % n]) {
                sb.append("a");
            } else {
                sb.append("b");
            }
        }
        SuffixArray sa = new SuffixArray(sb.toString());
        int[] pos = new int[n * 2], left = new int[sa.sa.length], right = new int[sa.sa.length];
        int v = -1;
        for (int i = 0; i< sa.sa.length; i++) {
            if (sa.sa[i] < pos.length) {
                pos[sa.sa[i]] = i;
            }
            left[i] = v;
            if (sa.sa[i] < n) {
                v = i;
            }
        }
        v = sa.sa.length;
        for (int i = sa.sa.length-1; i>=0; i--) {
            right[i] = v;
            if (sa.sa[i] < n) {
                v = i;
            }
        }
        for (int i = 0; i<n; i++) {
            int sol = 0;
            if (left[pos[i]] != -1) {
                sol = Math.max(sol, sa.queryLcp(left[pos[i]], pos[i]));
            }
            if (right[pos[i]] != sa.sa.length) {
                sol = Math.max(sol, sa.queryLcp(pos[i], right[pos[i]]));
            }
            if (sol >= n) {
                io.printf("%d\n", -1);
            } else {
                io.printf("%d\n", sol + 1);
            }
        }
        io.close();

    }
}