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

public class Bjarki {
    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 {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        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] = in.nextLong();
            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)));
        }
        System.out.printf("%d\n", res);
    }
}