// Java code to implement the approach

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

// User defined Pair class
class Pair {

    // Two variables to store start and end indices
    // respectively
    int x, y;

    // Constructor of Pair class
    Pair(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    // Function for returning length of a Pair(Formally
    // length of sub-array) According to 1 based indexing
    int length() { return (this.y - this.x) + 1; }
}
class GFG {

    // Function to get maximum Sum after
    // K queries
    static void maximumSum(int X[], int Y[], int N,
                           ArrayList<Pair> list, int K)
    {

        // Variable to calculate overall sum
        long sum = 0;

        // Maintaining two pointers to get
        // maximum and minimum element from
        // Y[]
        int s = 0;
        int e = Y.length - 1;

        // Loop for Traversing on Pairs
        for (int i = 0; i < list.size(); i++) {

            // Variable S holds start index
            // of query
            int S = list.get(i).x;

            // Variable E holds start index
            // of query
            int E = list.get(i).y;

            // length variable stores length
            // of sub-array using S and
            // E(1 based indexing)
            int length = list.get(i).length();

            // If length is even the minimum
            // element will be store in
            // "element" variable else Maximum
            // element will be store in it
            int element = length % 2 == 0 ? Y[s] : Y[e];

            // Removing chose element from
            // Y[]
            if (length % 2 == 0) {

                s++;
            }
            else {
                e--;
            }

            // Counter initialized to 1
            int counter = 1;

            // Loop for traversing on given
            // sub-array as queries
            // 1 based indexing, Therefore, S-1 to <E
            for (int j = S - 1; j < E; j++) {

                // The below if-else
                // conditions  is adding AP
                // of +ve and -ve elements
                if (counter % 2 != 0) {

                    X[j] = X[j] + (counter * element);
                }
                else {
                    X[j] = X[j] - (counter * element);
                }

                // Incrementing counter
                counter++;
            }
        }

        // Loop for traversing on X[] after
        // K Queries so that we can obtain
        // its sum
        for (int i = 0; i < N; i++) {

            // Adding element of X[] into
            // sum variable
            sum += X[i];
        }

        // Printing value of sum
        System.out.println(sum);
    }

    // Driver code
    public static void main(String[] args)
    {

        int N = 3;
        int[] X = { 1, 2, 3 };
        int[] Y = { 1, 3, 4 };
        int K = 2;

        // Start[] and end[] of K length
        // holds starting and ending indices
        // of sub-array
        int[] start = { 1, 1 };
        int[] end = { 3, 1 };

        // ArrayList of Pair type to store given start and
        // end indices as Pair<start, end>
        ArrayList<Pair> list = new ArrayList<>();

        // Loop for initializing list as Pairs
        for (int i = 0; i < K; i++) {
            list.add(new Pair(start[i], end[i]));
        }

        // Sorting list in descending order using user
        // defined Selection-sort function
        SortList(list);

        // sorting Y[] using in-built sort function
        Arrays.sort(Y);

        // function call for obtaining maximum sum
        maximumSum(X, Y, N, list, K);
    }

    // User defined Function for sorting list(Selection Sort
    // is used)
    static void SortList(ArrayList<Pair> list)
    {
        for (int i = 0; i < list.size() - 1; i++) {
            int max = i;
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(max).length()
                    < list.get(j).length()) {
                    max = j;
                }
            }
            Pair temp
                = new Pair(list.get(i).x, list.get(i).y);
            list.get(i).x = list.get(max).x;
            list.get(i).y = list.get(max).y;
            list.get(max).x = temp.x;
            list.get(max).y = temp.y;
        }
    }
}

// Java code to implement the approach

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

class GFG {

    // Function to get maximum value after K
    // queries
    static void maximumSum(int X[], int Y[], int N, int K,
                           ArrayList<Integer> list)
    {
        // Variable for holding maximum sum that can be
        // obtained
        long sum = 0;

        // Loop for calculating initial sum of X[]
        for (int i = 0; i < X.length; i++) {
            sum += X[i];
        }

        // Start pointer for Y[]
        int s = 0;

        // End pointer of Y[]
        int e = Y.length - 1;

        // Loop for Executing Queries in descending order of
        // length
        for (int i = list.size() - 1; i >= 0; i--) {

            // Variable to hold length of subarray
            int length = list.get(i);

            // element needed to be add optimally
            int element = length % 2 == 0 ? Y[s] : Y[e];

            // Increasing or decreasing start and end
            // pointers After using element at that pointers
            if (length % 2 == 0) {
                s++;
            }
            else {
                e--;
            }

            // Condition when length is even
            if (length % 2 == 0) {

                // Subtracting from the
                // overall sum
                sum = sum - ((length / 2) * element);
            }
            else {

                // Adding increment in
                // overall sum
                sum = sum + (((length + 1) / 2) * element);
            }
        }
        // Printing value of sum
        System.out.println(sum);
    }

    // Driver code
    public static void main(String[] args)
    {
        int N = 3;
        int[] X = { 1, 2, 3 };
        int[] Y = { 4, 3, 1 };
        int K = 2;

        // Start[] and end[] of K length holds
        // starting and ending indices
        // of sub-array
        int[] start = { 1, 1 };
        int[] end = { 1, 3 };

        // ArrayList of length of sub-arrays in each query
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < K; i++) {
            list.add((end[i] - start[i]) + 1);
        }

        // Sorting ArrayList
        list.sort(null);

        // Sorting Y[] using in-built sort function
        Arrays.sort(Y);

        // Function call for getting maximum Sum
        maximumSum(X, Y, N, K, list);
    }
}