You are given two integer arrays a and b of length n.

You can reverse at most one subarray (continuous subsegment) of the array a. 

Your task is to reverse such a subarray that the sum ∑_{i=1}^n a_i ⋅ b_i is maximized.

Input

The first line contains one integer n (1 ≤ n ≤ 5000).

The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^7).

The third line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 10^7).

Output

Print single integer — maximum possible sum after reversing at most one subarray (continuous subsegment) of a.

Examples

Input


5
2 3 2 1 3
1 3 2 4 2


Output


29


Input


2
13 37
2 4


Output


174


Input


6
1 8 7 6 3 6
5 9 6 8 8 6


Output


235

Note

In the first example, you can reverse the subarray [4, 5]. Then a = [2, 3, 2, 3, 1] and 2 ⋅ 1 + 3 ⋅ 3 + 2 ⋅ 2 + 3 ⋅ 4 + 1 ⋅ 2 = 29.

In the second example, you don't need to use the reverse operation. 13 ⋅ 2 + 37 ⋅ 4 = 174.

In the third example, you can reverse the subarray [3, 5]. Then a = [1, 8, 3, 6, 7, 6] and 1 ⋅ 5 + 8 ⋅ 9 + 3 ⋅ 6 + 6 ⋅ 8 + 7 ⋅ 8 + 6 ⋅ 6 = 235.
import java.util.*;
import java.io.*;
public class Main {
   
 
      static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
 
        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
 
        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(
                new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
 
        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    if (cnt != 0) {
                        break;
                    }
                    else {
                        continue;
                    }
                }
                buf[cnt++] = (byte)c;
            }
            return new String(buf, 0, cnt);
        }
 
        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
 
            if (neg)
                return -ret;
            return ret;
        }
 
        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
 
        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
 
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
 
            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }
 
            if (neg)
                return -ret;
            return ret;
        }
 
        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0,
                                 BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
 
        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
 
        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
     //System.out.println("YES");
//System.out.println("NO");
 
//int n=sc.nextInt();
//int a[]=new int[n];
//for(int i=0;i<n;i++)
//a[i]=sc.nextInt();
 
//int n=sc.nextInt();
//long a[]=new long[n];
//for(int i=0;i<n;i++)
//a[i]=sc.nextLong();
 
//System.out.println();
 
//String str=sc.next();
//long n=sc.nextLong();
   static long bs(long a[],ArrayList al[],long sol,int m) {
       int start = 1;
        int end = m-1;
        while(start<end)
        {
            int p = al[start].size();
            int k = al[end].size();
            if(Math.abs(p-k)<=1)
            {
                sol++;
            }
            else
            {
                sol+=Math.abs(p-k);
            }
            start++;
            end--;
        }
        return sol;
   }
   static long solve(int freq[],long a[],int m) {
        int ans=0;
      if(freq[0]>0) ans++;
      for(int i=1;i<=m/2;i++){
         if(freq[i]>0||freq[m-i]>0)  
         ans++;
         if(freq[i]==freq[m-i]){
            freq[i]=0;
            freq[m-i]=0;
         }
         else if(freq[i]>freq[m-i]){
            freq[i]-=(freq[m-i]+1);
            freq[m-i]=0;
 
         }
         else {
            freq[m-i]=freq[m-i]-(freq[i]+1);
            freq[i]=0;
         }
      }
 
      for(int i=1;i<m;i++){
         ans+=freq[i];
      }
      return ans;
   }
    public static void main(String[] args) throws IOException{
        Scanner sc=new Scanner(System.in);
      //  Reader sc=new Reader();
        PrintWriter out=new PrintWriter(System.out);
        int n = sc.nextInt();
       
        long a[]=new long[n];
        for(int i=0;i<n;i++)
        a[i]=sc.nextLong();
        long b[]=new long[n];
        for(int i=0;i<n;i++)
        b[i]=sc.nextLong();
		 
       long[] sum =  new long[n];
        long total = 0;
        for (int i = 0; i < n; i++) {
            total += a[i] * b[i];
            sum[i] = total;
        }
        long dp[][]=new long[n][n];
        for(int len=1;len<=n;len++) {
          for(int i=0;i<n-len+1;i++) {
                       int j=i+len-1;
                       if(i==j)
                       dp[i][j]=a[i]*b[i];
                       else if(j-i==1)
                       dp[i][j]=a[i]*b[j]+a[j]*b[i];
                       else 
                       dp[i][j]=dp[i+1][j-1]+a[i]*b[j]+a[j]*b[i];
                }
        }
        long ans=total;
        for(int i=0;i<n;i++) {
                for(int j=i;j<n;j++) {
                        long temp=total-(sum[j]-(i>0?sum[i-1]:0))+dp[i][j];
                         if (temp > ans) {
                         ans = temp;
                     }
                }
        }
        out.println(ans);
        
        
		
		out.flush();
		out.close();
}
}