Adilbek's house is located on a street which can be represented as the OX axis. This street is really dark, so Adilbek wants to install some post lamps to illuminate it. Street has n positions to install lamps, they correspond to the integer numbers from 0 to n - 1 on the OX axis. However, some positions are blocked and no post lamp can be placed there.

There are post lamps of different types which differ only by their power. When placed in position x, post lamp of power l illuminates the segment [x; x + l]. The power of each post lamp is always a positive integer number.

The post lamp shop provides an infinite amount of lamps of each type from power 1 to power k. Though each customer is only allowed to order post lamps of exactly one type. Post lamps of power l cost a_l each.

What is the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street? If some lamps illuminate any other segment of the street, Adilbek does not care, so, for example, he may place a lamp of power 3 in position n - 1 (even though its illumination zone doesn't completely belong to segment [0; n]).

Input

The first line contains three integer numbers n, m and k (1 ≤ k ≤ n ≤ 10^6, 0 ≤ m ≤ n) — the length of the segment of the street Adilbek wants to illuminate, the number of the blocked positions and the maximum power of the post lamp available.

The second line contains m integer numbers s_1, s_2, ..., s_m (0 ≤ s_1 < s_2 < ... s_m < n) — the blocked positions.

The third line contains k integer numbers a_1, a_2, ..., a_k (1 ≤ a_i ≤ 10^6) — the costs of the post lamps.

Output

Print the minimal total cost of the post lamps of exactly one type Adilbek can buy to illuminate the entire segment [0; n] of the street.

If illumintaing the entire segment [0; n] is impossible, print -1.

Examples

Input

6 2 3
1 3
1 2 3


Output

6


Input

4 3 4
1 2 3
1 10 100 1000


Output

1000


Input

5 1 5
0
3 3 3 3 3


Output

-1


Input

7 4 3
2 4 5 6
3 14 15


Output

-1
import java.io.*;
import java.math.BigInteger;
import java.sql.Struct;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.StringTokenizer;

public class Main {
    static class TEST_CASES {
        int n,m,k;
        int[] s,a,near,blocked;
        long get_cost(int power)
        {
            int now =0;
            long cost = 0;
            while(now<n)
            {
                assert(blocked[now]==1);
                cost+=(long) a[power-1];
                if(now+power>=n)
                {
                    now = n;
                }
                else{
                    if(near[now+power]==now)
                    {
                        return (long)1e18;
                    }
                    else{
                        now = near[now+power];
                    }
                }
            }
            return cost;
        }
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            n= in.nextInt ();
            m= in.nextInt ();
            k =in.nextInt ();
            s = new int[m];
            a = new int[k];
            near= new int[n];
            blocked = new int[n];
            s = in.nextIntArray (m);
            a = in.nextIntArray (k);
            for(int i=0;i<s.length;i++)
            {
                blocked[s[i]]= 1;
            }
            if(blocked[0]==1)
            {
                out.println ("-1");
                return;
            }
            int now = 0;
            for(int i=0;i<n;i++)
            {
                if(blocked[i]==0)
                {
                    now =i;
                    near[i] = i;
                }
                else{
                    near[i] = now;
                }
            }
            long mini = (long)1e18;
            for(int i=1;i<=k;i++)
            {
                mini = Math.min (mini, get_cost(i));
            }
            if(mini>=1e18)
            {
                mini = -1;
            }
            out.println (mini);

        }

    }

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader (inputStream);
        PrintWriter out = new PrintWriter (outputStream);
        int t = 1;
        //t = in.nextInt ();
        for (int i = 0; i < t; i++) {
            TEST_CASES solver = new TEST_CASES ();
            solver.solve (1, in, out);
        }
        out.close ();
    }

    static class InputReader {
        private boolean finished = false;

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException ();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read (buf);
                } catch (IOException e) {
                    throw new InputMismatchException ();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int peek() {
            if (numChars == -1) {
                return -1;
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read (buf);
                } catch (IOException e) {
                    return -1;
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar];
        }

        public int nextInt() {
            int c = read ();
            while (isSpaceChar (c)) {
                c = read ();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read ();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException ();
                }
                res *= 10;
                res += c - '0';
                c = read ();
            } while (!isSpaceChar (c));
            return res * sgn;
        }

        public long nextLong() {
            int c = read ();
            while (isSpaceChar (c)) {
                c = read ();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read ();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException ();
                }
                res *= 10;
                res += c - '0';
                c = read ();
            } while (!isSpaceChar (c));
            return res * sgn;
        }

        public String nextString() {
            int c = read ();
            while (isSpaceChar (c)) {
                c = read ();
            }
            StringBuilder res = new StringBuilder ();
            do {
                if (Character.isValidCodePoint (c)) {
                    res.appendCodePoint (c);
                }
                c = read ();
            } while (!isSpaceChar (c));
            return res.toString ();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar (c);
            }
            return isWhitespace (c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private String readLine0() {
            StringBuilder buf = new StringBuilder ();
            int c = read ();
            while (c != '\n' && c != -1) {
                if (c != '\r') {
                    buf.appendCodePoint (c);
                }
                c = read ();
            }
            return buf.toString ();
        }

        public String readLine() {
            String s = readLine0 ();
            while (s.trim ().length () == 0) {
                s = readLine0 ();
            }
            return s;
        }

        public String readLine(boolean ignoreEmptyLines) {
            if (ignoreEmptyLines) {
                return readLine ();
            }
            else {
                return readLine0 ();
            }
        }

        public BigInteger readBigInteger() {
            try {
                return new BigInteger (nextString ());
            } catch (NumberFormatException e) {
                throw new InputMismatchException ();
            }
        }

        public char nextCharacter() {
            int c = read ();
            while (isSpaceChar (c)) {
                c = read ();
            }
            return (char) c;
        }

        public double nextDouble() {
            int c = read ();
            while (isSpaceChar (c)) {
                c = read ();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read ();
            }
            double res = 0;
            while (!isSpaceChar (c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow (10, nextInt ());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException ();
                }
                res *= 10;
                res += c - '0';
                c = read ();
            }
            if (c == '.') {
                c = read ();
                double m = 1;
                while (!isSpaceChar (c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow (10, nextInt ());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException ();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read ();
                }
            }
            return res * sgn;
        }

        public boolean isExhausted() {
            int value;
            while (isSpaceChar (value = peek ()) && value != -1) {
                read ();
            }
            return value == -1;
        }

        public String next() {
            return nextString ();
        }

        public SpaceCharFilter getFilter() {
            return filter;
        }

        public void setFilter(SpaceCharFilter filter) {
            this.filter = filter;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }

        public int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; ++i) array[i] = nextInt ();
            return array;
        }

        public int[] nextSortedIntArray(int n) {
            int array[] = nextIntArray (n);
            Arrays.sort (array);
            return array;
        }

        public int[] nextSumIntArray(int n) {
            int[] array = new int[n];
            array[0] = nextInt ();
            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt ();
            return array;
        }

        public long[] nextLongArray(int n) {
            long[] array = new long[n];
            for (int i = 0; i < n; ++i) array[i] = nextLong ();
            return array;
        }

        public long[] nextSumLongArray(int n) {
            long[] array = new long[n];
            array[0] = nextInt ();
            for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt ();
            return array;
        }

        public long[] nextSortedLongArray(int n) {
            long array[] = nextLongArray (n);
            Arrays.sort (array);
            return array;
        }
    }

}
