You have a long stick, consisting of m segments enumerated from 1 to m. Each segment is 1 centimeter long. Sadly, some segments are broken and need to be repaired.

You have an infinitely long repair tape. You want to cut some pieces from the tape and use them to cover all of the broken segments. To be precise, a piece of tape of integer length t placed at some position s will cover segments s, s+1, …, s+t-1.

You are allowed to cover non-broken segments; it is also possible that some pieces of tape will overlap.

Time is money, so you want to cut at most k continuous pieces of tape to cover all the broken segments. What is the minimum total length of these pieces?

Input

The first line contains three integers n, m and k (1 ≤ n ≤ 10^5, n ≤ m ≤ 10^9, 1 ≤ k ≤ n) — the number of broken segments, the length of the stick and the maximum number of pieces you can use.

The second line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ m) — the positions of the broken segments. These integers are given in increasing order, that is, b_1 < b_2 < … < b_n.

Output

Print the minimum total length of the pieces.

Examples

Input

4 100 2
20 30 75 80


Output

17


Input

5 100 3
1 2 4 60 87


Output

6

Note

In the first example, you can use a piece of length 11 to cover the broken segments 20 and 30, and another piece of length 6 to cover 75 and 80, for a total length of 17.

In the second example, you can use a piece of length 4 to cover broken segments 1, 2 and 4, and two pieces of length 1 to cover broken segments 60 and 87.
//package com.company;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.sql.SQLOutput;
import java.util.*;
public class Main {

    public static void main(String[] args) throws IOException {
      //  Scanner s = new Scanner(System.in);
        StringBuilder sb=new StringBuilder();
        BufferedReader s=new BufferedReader(new InputStreamReader(System.in));
        String[] ss=s.readLine().trim().split("\\s+");

           int n=Integer.parseInt(ss[0]);
        int m=Integer.parseInt(ss[1]);
        int k=Integer.parseInt(ss[2]);
        Long[] a=new Long[n];
           Long [] ans=new Long[n-1];
           String[] ss1=s.readLine().trim().split("\\s+");
           for(int i=0;i<n;i++){
               a[i]=Long.parseLong(ss1[i]);
               if(i>0){
                   ans[i-1]=a[i]-a[i-1]+1;
               }
           }
           Arrays.sort(ans);
           int hu=n;int j=0;long fans=n;
           while(hu>k){
               fans+=ans[j++];hu--;
               fans-=2;
           }
        System.out.println(fans);

    }
    static  void computeLPSArray(String pat, int M, int lps[])
    {
        int len = 0;
        int i = 1;
        lps[0] = 0;
        while (i < M) {
            if (pat.charAt(i) == pat.charAt(len)) {
                len++;
                lps[i] = len;
                i++;
            }
            else // (pat[i] != pat[len])
            {
                if (len != 0) {
                    len = lps[len - 1];
                }
                else // if (len == 0)
                {
                    lps[i] = len;
                    i++;
                }
            }
        }
    }
    static boolean isPrime(int n)
    {
        if (n <= 1) return false;
        if (n <= 3) return true;

        if (n % 2 == 0 || n % 3 == 0) return false;

        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;

        return true;
    }

    static double power(double x, long y, int p) {
        double res = 1;
        x = x % p;
        while (y > 0) {
            if ((y & 1) == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }
    public static void fracion(double x) {
        String a = "" + x;
        String spilts[] = a.split("\\."); // split using decimal
        int b = spilts[1].length(); // find the decimal length
        int denominator = (int) Math.pow(10, b); // calculate the denominator
        int numerator = (int) (x * denominator); // calculate the nerumrator Ex
        // 1.2*10 = 12
        int gcd = (int)gcd((long)numerator, denominator); // Find the greatest common
        // divisor bw them
        String fraction = "" + numerator / gcd + "/" + denominator / gcd;
        // System.out.println((denominator/gcd));
        long x1=modInverse(denominator / gcd,998244353  );
        //  System.out.println(x1);
        System.out.println((((numerator / gcd )%998244353 *(x1%998244353  ))%998244353  ) );
    }static int anst=Integer.MAX_VALUE;
    static StringBuilder sb1=new StringBuilder();
    public static int bfs(int i1, ArrayList<Integer>[] h, int[] vis, int n,int val1) {
        Queue<Integer> q = new LinkedList<Integer>();
        q.add(i1);Queue<Integer> aq=new LinkedList<Integer>();
        aq.add(0);
        while(!q.isEmpty()){
            int i=q.poll();
            int val=aq.poll();
            if(i==n){
                return val;
            }
            if(h[i]!=null){
                for(Integer j:h[i]){
                    if(vis[j]==0){
                        q.add(j);vis[j]=1;
                        aq.add(val+1);}
                }
            }
        }return -1;
    }
    static int i(String a) {
        return Integer.parseInt(a);
    }
    static long l(String a) {
        return Long.parseLong(a);
    }
    static String[] inp() throws IOException {
        BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
        return s.readLine().trim().split("\\s+");
    }


    static long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
    static long modInverse(int a, int m)
    {


        {
            // If a and m are relatively prime, then modulo inverse
            // is a^(m-2) mode m
            return (power(a, m - 2, m));
        }
    }

    // To compute x^y under modulo m
    static long power(int x, int y, int m)
    {
        if (y == 0)
            return 1;

        long p = power(x, y / 2, m) % m;
        p = (p * p) % m;

        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    }

    // Function to return gcd of a and b

}
class Student
{
    int l;int r;
    public Student(int l, int r) {
        this.l = l;
        this.r = r;
    }
    // Constructor


    // Used to print student details in main()
    public String toString()
    {
        return this.l+" ";
    }
}

class Sortbyroll implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student a, Student b){
        if(a.l==b.l) return a.r-b.r;
        return b.l-a.l;  }
} class Sortbyroll1 implements Comparator<Student>
{
    // Used for sorting in ascending order of
    // roll number
    public int compare(Student a, Student b){
        if(a.r==b.r) return a.l-b.l;
        return b.l-a.l;
    }
}