Problem: You are given a sequence of n integers a1, a2, ..., an. 

Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.

The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.

The poorness of a segment is defined as the absolute value of sum of the elements of segment.

Input

The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.

The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).

Output

Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.

Examples

Input

3
1 2 3


Output

1.000000000000000


Input

4
1 2 3 4


Output

2.000000000000000


Input

10
1 10 2 9 3 8 4 7 5 6


Output

4.500000000000000

Note

For the first case, the optimal value of x is 2 so the sequence becomes  - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case. 

For the second sample the optimal value of x is 2.5 so the sequence becomes  - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case.

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
public class Solution {
	static class FastReader {
        BufferedReader br; 
        StringTokenizer st; 
        public FastReader() {
        	boolean env=System.getProperty("ONLINE_JUDGE") != null;
        	if(!env) {
        		try {
					br=new BufferedReader(new FileReader("src\\input.txt"));
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				}
        	}
        	else br = new BufferedReader(new InputStreamReader(System.in)); 
        } 
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) {
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 
        int nextInt() {
            return Integer.parseInt(next()); 
        } 
        long nextLong() {
            return Long.parseLong(next()); 
        } 
        double nextDouble() {
            return Double.parseDouble(next()); 
        } 
        String nextLine() {
            String str = ""; 
            try {
                str = br.readLine(); 
            } 
            catch (IOException e) {
                e.printStackTrace(); 
            } 
            return str; 
        } 
    }
	static FastReader sc=new FastReader();
	static PrintWriter out=new PrintWriter(System.out);
	//Main
	static int n;
	static double a[],eps=1e-11;;
	static double kadane(double arr[]) {
		double cur=0,res=0;
		for(int i=0;i<n;i++) {
			cur=Math.max(cur+arr[i], arr[i]);
			res=Math.max(res, cur);
		}
		return res;
	}
	static double check(double x) {
		double tmp[]=new double[n];
		for(int i=0;i<n;i++) tmp[i]=a[i]-x;
		double ans1=kadane(tmp);
		for(int i=0;i<n;i++) tmp[i]*=-1;
		double ans2=kadane(tmp);
		return Math.max(ans1, ans2);
	}
	public static void main(String args[]) {
		int test=1;
		//test=sc.nextInt();
		while(test-->0) {
			//Focus
			n=sc.nextInt();a=new double[n];
			double min=Double.MAX_VALUE,max=Double.MIN_VALUE;
			for(int i=0;i<n;i++) {
				a[i]=sc.nextDouble();
				min=Math.min(min, a[i]);
				max=Math.max(max, a[i]);
			}
			double l=min,r=max;
			for(int i=0;i<=100;i++) {
				double m1=l+(r-l)/3,m2=r-(r-l)/3;
				double f1=check(m1),f2=check(m2);
				if(f2<f1) l=m1;
				else r=m2;
			}
			double ans=Math.min(check(l), Math.min(check((l+r)/2), check(r)));
			out.printf("%.12f",ans);
		}
		out.flush();
		out.close();
	}
}