One day n friends gathered together to play "Mafia". During each round of the game some player must be the supervisor and other n - 1 people take part in the game. For each person we know in how many rounds he wants to be a player, not the supervisor: the i-th person wants to play ai rounds. What is the minimum number of rounds of the "Mafia" game they need to play to let each person play at least as many rounds as they want?

Input

The first line contains integer n (3 ≤ n ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the i-th number in the list is the number of rounds the i-th person wants to play.

Output

In a single line print a single integer — the minimum number of game rounds the friends need to let the i-th person play at least ai rounds.

Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

Examples

Input

3
3 2 2


Output

4


Input

4
2 2 2 2


Output

3

Note

You don't need to know the rules of "Mafia" to solve this problem. If you're curious, it's a game Russia got from the Soviet times: http://en.wikipedia.org/wiki/Mafia_(party_game).
import java.io.*;
import java.math.BigInteger;
import java.util.*;

 public class Main {
    static int arr[], N, K, p, s;
    static boolean adj[][];
    static BigInteger dp[][];
    static boolean reach[][];
    static  String str1 [];
     static String str2 [];
     public static void main(String[] args) throws IOException {
         Scanner sc = new Scanner(System.in);
         int n = sc.nextInt();
         arr = new int[n];
         double sum = 0;
          int max = 0;
         for(int i=0 ; i<n ; i++){
             arr[i] = sc.nextInt();
             sum+=arr[i];
             max = Math.max(max,arr[i]);
         }

         if(max >= Math.ceil(sum/(n-1)))
              System.out.println(max);
         else
             System.out.println((long) Math.ceil(sum/(n-1)));

     }
















     static class Point
     {
         int x;
         int y;

         public Point(int x, int y)
         {
             this.x = x;
             this.y = y;
         }

     };

     // Given three colinear points p, q, r, the function checks if
// point q lies on line segment 'pr'
     static boolean onSegment(Point p, Point q, Point r)
     {
         if (q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) &&
                 q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y))
             return true;

         return false;
     }

     // To find orientation of ordered triplet (p, q, r).
// The function returns following values
// 0 --> p, q and r are colinear
// 1 --> Clockwise
// 2 --> Counterclockwise
     static int orientation(Point p, Point q, Point r)
     {
         // See https://www.geeksforgeeks.org/orientation-3-ordered-points/
         // for details of below formula.
         int val = (q.y - p.y) * (r.x - q.x) -
                 (q.x - p.x) * (r.y - q.y);

         if (val == 0) return 0; // colinear

         return (val > 0)? 1: 2; // clock or counterclock wise
     }

     // The main function that returns true if line segment 'p1q1'
// and 'p2q2' intersect.
     static boolean doIntersect(Point p1, Point q1, Point p2, Point q2)
     {
         // Find the four orientations needed for general and
         // special cases
         int o1 = orientation(p1, q1, p2);
         int o2 = orientation(p1, q1, q2);
         int o3 = orientation(p2, q2, p1);
         int o4 = orientation(p2, q2, q1);

         // General case
         if (o1 != o2 && o3 != o4)
             return true;

         // Special Cases
         // p1, q1 and p2 are colinear and p2 lies on segment p1q1
         if (o1 == 0 && onSegment(p1, p2, q1)) return true;

         // p1, q1 and q2 are colinear and q2 lies on segment p1q1
         if (o2 == 0 && onSegment(p1, q2, q1)) return true;

         // p2, q2 and p1 are colinear and p1 lies on segment p2q2
         if (o3 == 0 && onSegment(p2, p1, q2)) return true;

         // p2, q2 and q1 are colinear and q1 lies on segment p2q2
         if (o4 == 0 && onSegment(p2, q1, q2)) return true;

         return false; // Doesn't fall in any of the above cases
     }

     static class Scanner
     {
         StringTokenizer st;
         BufferedReader br;

         public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
         public Scanner(String s) throws FileNotFoundException {
             br = new BufferedReader(new FileReader(s));
         }
         public String next() throws IOException
         {
             while (st == null || !st.hasMoreTokens())
                 st = new StringTokenizer(br.readLine());
             return st.nextToken();
         }

         public int nextInt() throws IOException {return Integer.parseInt(next());}

         public String nextLine() throws IOException {return br.readLine();}

         public long nextLong() throws IOException {return Long.parseLong(next());}

         public boolean ready() throws IOException {return br.ready();}
     }
 }

