6
12 8 12 17 20 5
17 4 8 8 8 4
 6
4 1 12 9 3 11
12 20 19 12 19 11
 1
1
1
 2
1 2
1 1
 1
7
5
 6
16 20 18 7 14 2
17 12 4 10 7 4

705
 917
 1
 9
 5
 741

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

// Solution

public class Main 
{    
  public static void main (String[] argv) 
  {
	  new Main();
  } 
     
  
  boolean test = true;  
  final int[][] dirs = {{0,1}, {0,-1}, {-1,0}, {1,0}, {1,1},{1,-1},{-1,1},{-1,-1}};
  final int MOD = 998244353;//1000000007;  
  int n_bit = 1000000;
  int[] bit;
  
  public Main()   {
	FastReader in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
	
     
    //FastReader in = new FastReader(new BufferedReader(new FileReader("Main.in")));   
    
    //int nt = in.nextInt();    
    int nt = 1;
    //StringBuilder sb = new StringBuilder();
    
    
    for (int it = 0; it < nt; it++) 
    {
       int n = in.nextInt();
       
       int[] a = new int[n];
       int[] b = new int[n];
       long[] dpU = new long[n];
       long[] dpD = new long[n];
       long[] fU = new long[n];
       long[] fD= new long[n];
       
       long[] sumU = new long[n];
       long[] sumD = new long[n];
       
       for (int i = 0; i < n; i++)
       {
           a[i] = in.nextInt();
       }
       
       for (int i = 0; i < n; i++)
       {
           b[i] = in.nextInt();
       }
       
       sumU[n-1] = a[n-1];
       sumD[n-1] = b[n-1];
       for (int i = n-2; i >= 0; i--)
       {
           sumU[i] = sumU[i+1] + a[i];
           sumD[i] = sumD[i+1] + b[i];           
       }
       fU[n-1] = b[n-1];
       fD[n-1] = a[n-1];
       
       for (int i = n-2; i >= 0; i--)
       {
           long mul = 2L * n - 2 * i - 1;
           fU[i] = fU[i+1] + (i+2 < n ? sumU[i+2] : 0) + sumD[i+1] + a[i+1] + b[i] * mul;
           fD[i] = fD[i+1] + (i+2 < n ? sumD[i+2] : 0) + sumU[i+1] + b[i+1] + a[i] * mul;        
       }
       
       dpU[n-1] = b[n-1];
       dpD[n-1] = a[n-1];
       for (int i = n - 2; i >= 0; i--)
       {
           long val =  (sumU[i+1] + sumD[i+1]) * 2;
           dpU[i] = Math.max(fU[i], b[i] + val + dpD[i+1]); 
           dpD[i] = Math.max(fD[i], a[i] + val + dpU[i+1]); 
       }
       //StringBuilder sb = new StringBuilder();
       //for (int v : ans)sb.append(nums[v-1] + "\n");
       
       System.out.println(dpU[0]);
       //System.out.print(sb);
    }
    //System.out.print(sb);
  }
  
  private boolean nextToSome(int[][] b, int SOME,  int i, int j, int n, int m)
  {
      if (i == 0 || i == n - 1 || j == 0 || j == m - 1) return true;
      
      for (int[] dir : dirs)
      {
          int x = i + dir[0], y = j + dir[1];
          if (b[x][y] == SOME)
              return true;
      }
      return false;
  }
  
  private int query(int p)
  {
      int sum = 0;
      for (; p > 0; p -= (p & (-p)))
      {
          sum += bit[p];
      }
      return sum;
  }
  
  private void add(int p, int val)
  {
      //System.out.println("add to BIT " + p);
      for (; p <= n_bit; p += (p & (-p)))
      {
          bit[p] += val;
      }
  }
  
  
  
  private List<Integer> getMinFactor(int sum)
  {
      List<Integer>  factors = new ArrayList<>();
      
               for (int sz = 2; sz <= sum / sz; sz++){
                   if (sum % sz == 0) {
                       factors.add(sz);
                       factors.add(sum / sz);
                   }
               }
               if (factors.size() == 0)
                   factors.add(sum);
          
      return factors;
  }
  
  /* Tree class */
  class Tree {
      int V = 0;
      int root = 0;
      List<Integer>[] nbs;
      int[][] timeRange;
      int[] subTreeSize;
      int t;
      boolean dump = false;
      
      public Tree(int V, int root)
      {
          if (dump) 
              System.out.println("build tree with size = " + V + ", root = " + root); 
          
          this.V = V;          
          this.root = root;
          nbs = new List[V];
          subTreeSize = new int[V];
          for (int i = 0; i < V; i++)
              nbs[i] = new ArrayList<>();
          
              
      }
      
      public void doneInput()
      {
          dfsEuler();
      }
      
      public void addEdge(int p, int q)
      {
          nbs[p].add(q);
          nbs[q].add(p);
      }
      
      private void dfsEuler()
      {
          timeRange = new int[V][2];          
          t = 1;
          dfs(root);           
      }
      
      private void dfs(int node)
      {
          if (dump)
              System.out.println("dfs on node " + node + ", at time " + t);
          timeRange[node][0] = t;
          
          for (int next : nbs[node]) {
              if (timeRange[next][0] == 0)
              {
                  ++t;
                  dfs(next);                  
              }
          }
          timeRange[node][1] = t;
          subTreeSize[node] = t - timeRange[node][0] + 1;
      }
      
      public List<Integer> getNeighbors(int p) {
          return nbs[p];
      }
      
      public int[] getSubTreeSize(){
          return subTreeSize;
      }
      
      public int[][] getTimeRange()
      {
          if (dump){
              for (int i = 0; i < V; i++){
                  System.out.println(i + ": " + timeRange[i][0] + " - " + timeRange[i][1]);
              }
          }
          return timeRange;
      }
      
  }
  
  /* segment tree */
  class SegTree {
      long[] tree;
      long[] lazy;
      int n;
      boolean dump = false;
      
      public SegTree(int n)
      {
          if (dump)
              System.out.println("create segTree with size " + n);
          this.n = n;
          tree = new long[n*4];
          lazy = new long[n*4];
      }
      
      public SegTree(int n, int[] a) {
          this(n);
          buildTree(1, 0, n-1, a);
      }
      
      private void buildTree(int node, int lo, int hi, int[] a)
      {
          if (lo == hi) {
              tree[node] = a[lo];
              return;
          }
          
          int m = (lo + hi) / 2;
          buildTree(node * 2, lo, m, a);
          buildTree(node * 2 + 1, m + 1, hi, a);
          pushUp(node, lo, hi);
      }
      
      
      private void pushUp(int node, int lo, int hi)
      {
          if (lo >= hi) return;
          
          // add combine fcn
      }
      
      private void pushDown(int node, int lo, int hi)
      {
          if (lo > hi || lazy[node] == 0) return;
          
          tree[node] += lazy[node];
          tree[node] %= MOD;
          
          if (lo < hi) {              
              lazy[node * 2] += lazy[node];
              lazy[node * 2 + 1] += lazy[node];
              lazy[node * 2] %= MOD;
              lazy[node * 2 + 1] %= MOD;
          }
          
          lazy[node] = 0;
      }
      
      public void rangeUpdate(int fr, int to, long val)
      {
          if (dump)
              System.out.println("rangeUpdate : " + fr + " - " + to + " delta = " + val);
          rangeUpdate(1, 0, n-1, fr, to, val);
      }
      
      public long pointQuery(int p)
      {
          return pointQuery(1, 0, n-1, p);
      }
      
      
      private void rangeUpdate(int node, int lo, int hi, int fr, int to, long val)
      {
          if (dump)
              System.out.println("rangeUpdate : " + node + "[" + lo + " - " + hi + "]" + fr + " - " + to + " delta = " + val);
          
          pushDown(node, lo, hi);
          
          if (lo == fr && hi == to) {
              lazy[node] = val;              
              return;
          }
          
          int m = (lo + hi) / 2;
          if (to <=  m) 
              rangeUpdate(node * 2 , lo, m, fr, to, val);
          else if (fr > m)
              rangeUpdate(node * 2 + 1, m + 1, hi, fr, to, val);
          else {
              rangeUpdate(node * 2, lo, m, fr, m, val);
              rangeUpdate(node * 2 + 1, m + 1, hi, m + 1, to, val);
          }
          
          pushUp(node, lo, hi);          
      }
  
      /* pre-condition: lo <= p <= hi */
      private long pointQuery(int node, int lo, int hi, int p)
      {
          pushDown(node, lo, hi);
          
          if (lo == hi)
          {
              return tree[node];
          }
          
          int m = (lo + hi) / 2;
          if (p <= m) 
              return pointQuery(node * 2, lo, m, p);
          else
              return pointQuery(node * 2 + 1, m + 1, hi, p);
      }      
  
  }
  
  
  private long inv(long v)
  {
      return pow(v, MOD-2);
  }
  
  private long pow(long v, int p)
  {
      long ans = 1;
      while (p > 0)
      {
          if (p % 2 == 1)
              ans = ans * v % MOD;
          v = v * v % MOD;
          p = p / 2;
      }
      return ans;
  }
  
  private double dist(double x, double y, double xx, double yy)
  {
      return Math.sqrt((xx - x) * (xx - x) + (yy - y) * (yy - y));
  }
  

  
 
  private int mod_add(int a, int b) {
      int v = a + b;
      if (v >= MOD) v -= MOD;
      return v;
  }
  
  
  private long overlap(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
      if (x1 > x3) return overlap(x3, y3, x4, y4, x1, y1, x2, y2);
      
      if (x3 > x2 || y4 < y1 || y3 > y2) return 0L;
      
      //(x3, ?, x2, ?)
      int yL = Math.max(y1, y3);
      int yH = Math.min(y2, y4); 
      int xH = Math.min(x2, x4);
      
      return f(x3, yL, xH, yH);
  }
  //return #black cells in rectangle
  private long f(int x1, int y1, int x2, int y2) {
      long dx = 1L + x2 - x1;
      long dy = 1L + y2 - y1;
      if (dx % 2 == 0 || dy % 2 == 0 || (x1 + y1) % 2 == 0) 
          return 1L * dx * dy / 2;
      return 1L * dx * dy / 2 + 1;
  }
  
  private int distM(int x, int y, int xx, int yy) {
      return abs(x - xx) + abs(y - yy);
  }
  
  private boolean less(int x, int y, int xx, int yy) {
      return x < xx || y > yy;
  }
  
  private int mul(int x, int y) {
      return (int)(1L * x * y % MOD);
  }
  
  
 
  
  private int nBit1(int v) {
      int v0 = v;
      int c = 0;
      while (v != 0) {
          ++c;
          v = v & (v - 1);
      }
      return c;
  }
  
  private long abs(long v) {
      return v > 0 ? v : -v;
  }
  
  private int abs(int v) {
      return v > 0 ? v : -v;
  }
  
  private int common(int v) {
      int c = 0;
      while (v != 1) {
          v = (v >>> 1);
          ++c;
      }
      
      return c;
  }
  
  private void reverse(char[] a, int i, int j) {
      while (i < j) {
          swap(a, i++, j--);
      }
  }
  
  private void swap(char[] a, int i, int j) {
      char t = a[i];
      a[i] = a[j];
      a[j] = t;
  }
  
  private int gcd(int x, int y) {
      if (y == 0) return x;
      return gcd(y, x % y);
  }
  private long gcd(long x, long y) {
      if (y == 0) return x;
      return gcd(y, x % y);
  }
  private int max(int a, int b) {
      return a >  b ? a : b;
  }
  
  private long max(long a, long b) {
      return a >  b ? a : b;
  }
  
  private int min(int a, int b) {
      return a >  b ? b : a;
  }
  
  private long min(long a, long b) {
      return a >  b ? b : a;
  }
  
  static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader(BufferedReader in)
        {            
            br = in;
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    String line = br.readLine();
                    if (line == null || line.length() == 0) return "";
                    st = new StringTokenizer(line);
                }
                catch (IOException  e)
                {
                    return "";
                    //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)
            {
                return null;
                //e.printStackTrace();
            }
            return str;
        }
    }
}