import java.io.*;
import java.util.*;

public class Bjarki_fast_input {
    static long[] sm;
    static long[] arr;
    static long[] mem;
    static int[] L;
    static int[] R;
    static int n;

    public static long opt(int at) {
        if (mem[at] != -1) {
            return mem[at];
        }
        int l = L[at]+1, r = R[at]-1;
        long cur = sm[r];
        if (l > 0) {
            cur -= sm[l-1];
        }
        if (l == 0 && r == n-1) {
            return 0;
        }
        long lval = l-1 >= 0 ? arr[l-1] : 9000000000000000000L;
        long rval = r+1 < n ? arr[r+1] : 9000000000000000000L;
        long res;
        if (lval < rval) {
            res = Math.max(Math.max(0L, lval-cur), opt(l-1));
        } else {
            res = Math.max(Math.max(0L, rval-cur), opt(r+1));
        }
        return mem[at] = res;
    }

    public static void main(String[] args) throws Exception {
        Kattio io = new Kattio(System.in);
        n = io.getInt();
        sm = new long[n];
        L = new int[n];
        R = new int[n];
        arr = new long[n];
        mem = new long[n];
        int mx = 0;
        for (int i = 0; i < n; i++) {
            mem[i] = -1;
            arr[i] = io.getLong();
            if (arr[i] > arr[mx]) {
                mx = i;
            }
        }
        long[] tmp = new long[n];
        for (int i = 0; i < n; i++) {
            tmp[i] = arr[(i+mx)%n];
        }
        arr = tmp;
        for (int i = 0; i < n; i++) {
            sm[i] = arr[i];
            if (i > 0) {
                sm[i] += sm[i-1];
            }
        }
        Stack<Integer> S = new Stack<Integer>();
        for (int i = 0; i < n; i++) {
            while (!S.empty() && arr[S.peek()] < arr[i]) {
                S.pop();
            }
            L[i] = S.empty() ? -1 : S.peek();
            S.push(i);
        }
        S = new Stack<Integer>();
        for (int i = n-1; i >= 0; i--) {
            while (!S.empty() && arr[S.peek()] <= arr[i]) {
                S.pop();
            }
            R[i] = S.empty() ? n : S.peek();
            S.push(i);
        }
        long res = 9000000000000000000L;
        for (int i = 0; i < n; i++) {
            res = Math.min(res, Math.max(arr[i], opt(i)));
        }
        io.printf("%d\n", res);
        io.flush();
    }

    static 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;
        }
    }
}