The finalists of the "Russian Code Cup" competition in 2214 will be the participants who win in one of the elimination rounds.The elimination rounds are divided into main and additional. Each of the main elimination rounds consists of c problems, the winners of the round are the first n people in the rating list. Each of the additional elimination rounds consists of d problems. The winner of the additional round is one person. Besides, k winners of the past finals are invited to the finals without elimination.As a result of all elimination rounds at least n·m people should go to the finals. You need to organize elimination rounds in such a way, that at least n·m people go to the finals, and the total amount of used problems in all rounds is as small as possible.

The first line contains two integers c and d (1 ≤ c, d ≤ 100) — the number of problems in the main and additional rounds, correspondingly. The second line contains two integers n and m (1 ≤ n, m ≤ 100). Finally, the third line contains an integer k (1 ≤ k ≤ 100) — the number of the pre-chosen winners.

In the first line, print a single integer — the minimum number of problems the jury needs to prepare.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
//package RCC2014;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

/**
 *
 * @author tino chagua
 */
public class A {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] cad = br.readLine().split(" ");
        int c = Integer.valueOf(cad[0]);
        int d = Integer.valueOf(cad[1]);

        cad = br.readLine().split(" ");
        int n = Integer.valueOf(cad[0]);
        int m = Integer.valueOf(cad[1]);

        int k = Integer.valueOf(br.readLine());

        int min = n * m - k;

        if (min <= 0) {
            System.out.println(0);
            return;
        }

        int[] total = new int[min + 1];

        for (int y = 0; y < min + 1; y++) {
            int aux = min - y;
            int x = (aux / n);
            if (aux % n != 0) {
                x++;
            }
            total[y] = x * c + y * d;
        }
        Arrays.sort(total);
        System.out.println(total[0]);
    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);

		int c = cin.nextInt(), d = cin.nextInt(), n = cin.nextInt(), m = cin
				.nextInt(), k = cin.nextInt();

		int min = (m * n - k <= 0) ? 0 : Integer.MAX_VALUE;
		for (int i = 0; i <= m * n - k; i++) {
			int j = (int) Math.ceil((m * n - k - i) / (double) n);
			min = Math.min(min, c * j + d * i);
		}

		System.out.println(min);
		cin.close();
	}

}

import java.util.Scanner;
public class Q417A2
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();
        int no_of_problems = 0;
        int no_of_winners = k;
        while(no_of_winners < n*m)
        {
            if(c/n <= d && (n*m-no_of_winners)*d > c)
            {
                no_of_winners += n;
                no_of_problems += c;
            }
            else
            {
                no_of_winners += 1;
                no_of_problems += d;
            }
        }
        System.out.println(no_of_problems);
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.*;

public class DZYLovesHash {

    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(in, out);
        out.close();
    }
}

class TaskA {

    public void solve(InputReader in, PrintWriter out) {
        long c = in.nextLong();
        long d = in.nextLong();
        long n = in.nextLong();
        long m = in.nextLong();
        long k = in.nextLong();

        long remain = m*n - k;

        if(remain <= 0)
        {
            out.println(0);
            return;
        }

        long res = 0;
        if(c/n < d)
        {
            res = (remain/n)*c;
            remain -= (remain/n)*n;
            if(remain > 0)
            {
                res += Math.min(c, d*remain);
            }
        }
        else
        {
            res = d*remain;
        }
        out.println(res);
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Lokesh Khandelwal
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int c = in.nextInt(), d = in.nextInt(), n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
        int total = n * m - k;
        int steps = d, co = 1;
        double p = c / (double)n;
        if(p < d) {
            steps = c;
            co = n;
        }
        int ans = 0;
        while (total > 0) {
            if(total < n) {
                ans += Math.min(d * total, c);
                break;
            }
            ans += steps;
            total -= co;
        }
        out.printLine(ans);
    }
}

class InputReader
{
    BufferedReader in;
    StringTokenizer tokenizer=null;

    public InputReader(InputStream inputStream)
    {
        in=new BufferedReader(new InputStreamReader(inputStream));
    }
    public String next()
    {
        try{
            while (tokenizer==null||!tokenizer.hasMoreTokens())
            {
                tokenizer=new StringTokenizer(in.readLine());
            }
            return tokenizer.nextToken();
        }
        catch (IOException e)
        {
            return null;
        }
    }
    public int nextInt()
    {
        return Integer.parseInt(next());
    }
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}

	public OutputWriter(Writer writer) {
		this.writer = new PrintWriter(writer);
	}

	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

	public void printLine(Object...objects) {
		print(objects);
		writer.println();
	}

	public void close() {
		writer.close();
	}
}

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

/**
 * @author master_j
 */
public class Solution {
    private IO io;
    private static final String _localArg = "master_j";
    private final String _problemName = "";
    private final int _inMode = IO.STD_;
    private final int _outMode = IO.STD_;
    private final boolean _autoFlush = false;

    private void solve() throws IOException {
        int c = io.nI(), d = io.nI();
        int n = io.nI(), m = io.nI();
        int k = io.nI();
        int ans = Integer.MAX_VALUE;

        for(int dop = 0; dop <= n*m; dop++)
            for(int osn = 0; osn <= n*m; osn++)
                if(n*m <= k + osn*n + dop)
                    ans = Math.min(ans, osn*c + dop*d);

        io.wln(ans);
    }//2.2250738585072012e-308

    private void init(boolean local) throws IOException {
        if(local)
            io = new IO(IO._PUT_TXT, IO.STD_);
        else{
            if((_inMode == IO.PROBNAME_ || _outMode == IO.PROBNAME_) && _problemName.length() == 0)
                throw new IllegalStateException("You imbecile. Where's my <_problemName>?");
            io = new IO(_inMode, _outMode);
        }

        long nanoTime = 0;
        if(local){
            nanoTime -= System.nanoTime();
            if(_autoFlush)
                io.wln("NOTE: auto-flush is on.");
            io.wln("<output>");
            io.flush();
        }

        solve();
        io.flush();

        if(local){
            io.wln("</output>");
            nanoTime += System.nanoTime();
            long d9 = 1000000000, d6 = 1000000, d3 = 1000;
            if(nanoTime >= d9)
                io.wf("%d.%d seconds\n", nanoTime/d9, nanoTime%d9);
            else if(nanoTime >= d6)
                io.wf("%d.%d millis\n", nanoTime/d6, nanoTime%d6);
            else if(nanoTime >= d3)
                io.wf("%d.%d micros\n", nanoTime/d3, nanoTime%d3);
            else
                io.wf("%d nanos\n", nanoTime);
            io.flush();
        }

        io.close();
    }

    /**
     * Input-output class
     *
     * @author master_j
     * @version 0.3.2
     */
    private class IO {
//     _____________________________ _________________
//    |  mode  |      from/to       |  variable name  |
//    |--------|--------------------|-----------------|
//    |    0   |      System.*      |       STD_      |
//    |    1   |      *put.txt      |     _PUT_TXT    |
//    |    2   |  <_problemName>.*  |     PROBNAME_   |
//    |________|____________________|_________________|
//

        static final int STD_ = 0;
        static final int _PUT_TXT = 1;
        static final int PROBNAME_ = 2;

        StreamTokenizer st;
        BufferedReader br;
        Reader reader;

        PrintWriter pw;
        Writer writer;

        IO(int inMode, int outMode) throws IOException {
            Locale.setDefault(Locale.US);

            if(inMode == IO.STD_)
                reader = new InputStreamReader(System.in);
            else if(inMode == IO._PUT_TXT)
                reader = new FileReader("input.txt");
            else if(inMode == IO.PROBNAME_)
                reader = new FileReader(_problemName + ".in");
            else
                throw new IllegalStateException("You imbecile. How did you do that?");

            if(outMode == IO.STD_)
                writer = new OutputStreamWriter(System.out);
            else if(outMode == IO._PUT_TXT)
                writer = new FileWriter("output.txt");
            else if(outMode == IO.PROBNAME_)
                writer = new FileWriter(_problemName + ".out");
            else
                throw new IllegalStateException("You imbecille. Why did you do that?");

            br = new BufferedReader(reader);
            st = new StreamTokenizer(br);

            pw = new PrintWriter(writer, _autoFlush);
        }

        void wln()          {pw.println(); }
        void wln(boolean x) {pw.println(x);}
        void wln(char x)    {pw.println(x);}
        void wln(char x[])  {pw.println(x);}
        void wln(double x)  {pw.println(x);}
        void wln(float x)   {pw.println(x);}
        void wln(int x)     {pw.println(x);}
        void wln(long x)    {pw.println(x);}
        void wln(Object x)  {pw.println(x);}
        void wln(String x)  {pw.println(x);}

        void wf(String f, Object...o){pw.printf(f, o);}

        void w(boolean x)   {pw.print(x);}
        void w(char x)      {pw.print(x);}
        void w(char x[])    {pw.print(x);}
        void w(double x)    {pw.print(x);}
        void w(float x)     {pw.print(x);}
        void w(int x)       {pw.print(x);}
        void w(long x)      {pw.print(x);}
        void w(Object x)    {pw.print(x);}
        void w(String x)    {pw.print(x);}

        int nI() throws IOException    {st.nextToken(); return (int)st.nval;}
        double nD() throws IOException {st.nextToken(); return st.nval;}
        float nF() throws IOException  {st.nextToken(); return (float)st.nval;}
        long nL() throws IOException   {st.nextToken(); return (long)st.nval;}
        String nS() throws IOException {st.nextToken(); return st.sval;}

        void wc(String x){ wc(x.toCharArray()); }
        void wc(char c1, char c2){for(char c = c1; c<=c2; c++)wc(c);}
        void wc(char x[]){
            for(char c : x)
                wc(c);
        }
        void wc(char x){st.ordinaryChar(x); st.wordChars(x, x);}

        public boolean eof() {return st.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol() {return st.ttype == StreamTokenizer.TT_EOL;}

        void flush(){pw.flush();}
        void close() throws IOException{reader.close(); br.close(); flush(); pw.close();}
    }

    public static void main(final String args[]) throws IOException {
        new Solution().init(args.length == 1 && args[0].equals(_localArg));
    }
}

import java.util.Scanner;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int res = k;
        int dest = n*m;
        int q = 0;
        while (res < dest){
            if (n > (dest - res)){
                if (d*(dest - res) < c){
                    int v = (dest - res);
                    q += d*v;
                    res += v;
                }
                else {
                    q += c;
                    res += n;
                }
            }
            else{
                if (d*n < c){
                    q += d*n;
                    res += n;
                }
                else {
                    q += c;
                    res += n;
                }
            }
        }
        out.print(q);
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;

public class Main{
	static int c , d  , n , m;
	static int memo[];
	public static int search(int remP)
	{
		if(remP<=0)
			return 0;
		if(memo[remP]!=-1)
			return memo[remP];
		return memo[remP]=Math.min(d+search(remP-1), c+search(remP-n));
	}
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		c = sc.nextInt() ; d = sc.nextInt();
		n = sc.nextInt() ; m = sc.nextInt();
		int k = sc.nextInt();
		memo = new int[100001];
		Arrays.fill(memo, -1);
		System.out.println(search(n*m-k));
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

}

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

public class Main {

	public static void main(String[] args) throws IOException {

		//BufferedReader cin = new BufferedReader(new FileReader("test.txt"));
		 BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));

		String line;
		StringTokenizer st;

		line = cin.readLine();
		st = new StringTokenizer(line);

		int c = Integer.parseInt(st.nextToken());
		int d = Integer.parseInt(st.nextToken());
		//int b = Integer.parseInt(st.nextToken());

		line = cin.readLine();
		st = new StringTokenizer(line);

		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());

		line = cin.readLine();
		int k = Integer.parseInt(line);

		int need = n*m-k;
		int prob=0;
		int min;//last round problems
		if(need>0){
			double r = (double)c/n;
			if(r>=d)prob=d*need;//use all additional
			else{
				int mult = need/n;//how many main rounds
				int remain = need%n;
				prob=mult*c;
				min = Math.min(c, remain*d);
				prob+=min;
			}
		}
		System.out.println(prob);

		cin.close();
	}

}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class T417A {

	public int solve(int c, int d, int n, int m, int k) {
		int res = n * m - k;

		int ans = 0;
		while (res > 0) {
			if (res >= n) {
				ans += Math.min(c, d * n);
				res -= n;
			} else {
				ans += Math.min(c, d * res);
				res = 0;
			}
		}
		return ans;
	}
	public static void main(String[] args) {
		FastScanner in = new FastScanner();
		System.out.println(new T417A().solve(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt()));

	}
	static class FastScanner {

		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

	}
}

import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
public class A {
    public static void main(String[] args) throws Exception {
        Scanner scan = new Scanner(System.in);
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int c = scan.nextInt();
        int d = scan.nextInt();
        int n = scan.nextInt();
        int m = scan.nextInt();
        int k = scan.nextInt();
        int ans = 0;
        if(n*m-k<= 0)
            ans = 0;
        else if(d*n > c) {
            ans = (n*m-k)/n * c;
            ans += Math.min(d*(n*m-k-n*((n*m-k)/n)), c);
        }
        else
            ans = d*(n*m-k);
        System.out.println(ans);
    }
}

import java.util.InputMismatchException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int res = (int) 1e9;
        for (int i = 0; i * n <= n * m; ++i) {
            int j = n * m - i * n - k;
            j = j < 0 ? 0 : j;
            res = Math.min(res, i * c + j * d);
        }
        out.println(res);
    }
}

class InputReader {
    BufferedReader in;
    StringTokenizer st;

    public InputReader(InputStream stream) {
        in = new BufferedReader(new InputStreamReader(stream));
        eat("");
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public String next() {
        while (!st.hasMoreTokens())
            eat(nextLine());
        return st.nextToken();
    }

    public String nextLine() {
        try {
            return in.readLine();
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    public void eat(String str) {
        if (str == null) throw new InputMismatchException();
        st = new StringTokenizer(str);
    }
}

import java.util.Scanner;

public class First {

	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt(), d = sc.nextInt(), n = sc.nextInt(), m = sc.nextInt(), k = sc.nextInt();
		int num = 0;
		int numNeed = n*m - k;
		if(numNeed > 0){
		if(c < d*n){
			num+=c*(numNeed/n);
			int numOst = numNeed%n;
			num+=Math.min(numOst*d, c);

		}
		else{
			num+=numNeed*d;
		}}
		else
			numNeed = 0;
		System.out.print(num);
	}
}

import java.util.*;
import java.lang.*;
import java.io.*;
public class Codechef
{       static PrintWriter out=new PrintWriter(System.out);static FastScanner in = new FastScanner(System.in);static class FastScanner {BufferedReader br;StringTokenizer stok;FastScanner(InputStream is) {br = new BufferedReader(new InputStreamReader(is));}
        String next() throws IOException {while (stok == null || !stok.hasMoreTokens()) {String s = br.readLine();if (s == null) {return null;}
                stok = new StringTokenizer(s);}return stok.nextToken();}
        int ni() throws IOException {return Integer.parseInt(next());}long nl() throws IOException {return Long.parseLong(next());}double nd() throws IOException {return Double.parseDouble(next());}char nc() throws IOException {return (char) (br.read());}String ns() throws IOException {return br.readLine();}
        int[] nia(int n) throws IOException{int a[] = new int[n];for (int i = 0; i < n; i++)a[i] = ni();return a;}long[] nla(int n) throws IOException {long a[] = new long[n];for (int i = 0; i < n; i++)a[i] = nl();return a;}
        double[] nda(int n)throws IOException {double a[] = new double[n];for (int i = 0; i < n; i++)a[i] = nd();return a;}int [][] imat(int n,int m) throws IOException{int mat[][]=new int[n][m];for(int i=0;i<n;i++){for(int j=0;j<m;j++)mat[i][j]=ni();}return mat;}
    }
	static long mod=Long.MAX_VALUE;
	public static void main (String[] args) throws java.lang.Exception
	{   int i,j;
	    int c=in.ni();
	    int d=in.ni();
	    int n=in.ni();
	    int m=in.ni();
	    int k=in.ni();
	    int temp=Math.max(0,n*m-k);
	    int people=temp;
	    //for(i=0;i<=24;i++)
	    //    out.println("i="+i+" "+solve(i,0,c,d,n));
	    //out.println("_____________________");
	    int dp[]=new int[10009];
	    dp[0]=0;
	    for(i=1;i<=10006;i++)
	    {   dp[i]=dp[i-1]+d;
	        for(j=Math.max(0,i-n);j<i;j++)
	            dp[i]=Math.min(dp[j]+c,dp[i]);
	    }
	    //for(i=0;i<=n*m;i++)
	    //    out.println("i="+i+" "+dp[i]);
	    out.println(dp[people]);

        out.close();
	}
	static int solve(int people,int ans,int c,int d,int n)
	{
	    if(people<=0)
	        return ans;
	    return Math.min(solve(people-n,ans+c,c,d,n),solve(people-1,ans+d,c,d,n));
	}
	static class pair implements Comparable<pair>{
		int x, y;
		public pair(int x, int y){this.x = x; this.y = y;}
		@Override
		public int compareTo(pair arg0)
		{   if(x<arg0.x)    return -1;
		    else if(x==arg0.x)
		    {   if(y<arg0.y)    return -1;
		        else if(y>arg0.y)   return 1;
		        else    return 0;
		    }
		    else    return 1;
		}
	}
	static long gcd(long a,long b)
	{   if(b==0)
	        return a;
	    return gcd(b,a%b);
	}
	static long exponent(long a,long n)
	{   long ans=1;
	    while(n!=0)
	    {   if(n%2==1)
	            ans=(ans*a)%mod;
	       a=(a*a)%mod;
	       n=n>>1;
	    }
	    return ans;
	}
	static int binarySearch(int a[], int item, int low, int high)
    {   if (high <= low)
            return (item > a[low])?  (low + 1): low;
        int mid = (low + high)/2;
        if(item == a[mid])
            return mid+1;
        if(item > a[mid])
            return binarySearch(a, item, mid+1, high);
        return binarySearch(a, item, low, mid-1);
    }
    static void merge(int arr[], int l, int m, int r) {
        int n1 = m - l + 1; int n2 = r - m; int L[] = new int [n1]; int R[] = new int [n2];

        for (int i=0; i<n1; ++i) L[i] = arr[l + i]; for (int j=0; j<n2; ++j) R[j] = arr[m + 1+ j]; int i = 0, j = 0; int k = l; while (i < n1 && j < n2) {   if (L[i] <= R[j]) {   arr[k] = L[i]; i++; } else{   arr[k] = R[j]; j++; } k++; } while (i < n1){   arr[k] = L[i]; i++; k++; } while (j < n2) { arr[k] = R[j];   j++;     k++; }
    }
    static void Sort(int arr[], int l, int r) {if (l < r) {   int m = (l+r)/2; Sort(arr, l, m); Sort(arr , m+1, r); merge(arr, l, m, r); } }

    static void sort(int a[])
    {Sort(a,0,a.length-1);}
}

import java.util.*;
import java.lang.*;
import java.io.*;
public class P1
{
	public static void main (String[] args) throws java.lang.Exception
	{
	Scanner sc = new Scanner(System.in);
        int cb = sc.nextInt();
        int ca = sc.nextInt();
        int na = sc.nextInt();
        int nb = sc.nextInt();
        int k =  sc.nextInt();

        nb -= k / na;
        k %= na;

        if (nb <= 0)
        {
            System.out.println(0);
            System.exit(0);
        }
        System.out.println(Math.min(nb * cb, Math.min((na - k) * ca + (nb - 1) * cb, (na - k) * ca + (nb - 1) * na * ca)));
    }

}

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

public class CJ2 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String inp[] = br.readLine().split(" ");
		int c = Integer.parseInt(inp[0]);
		int d = Integer.parseInt(inp[1]);
		inp=br.readLine().split(" ");
		int n = Integer.parseInt(inp[0]);
		int m = Integer.parseInt(inp[1]);
		int k= Integer.parseInt(br.readLine());
		int minfinalists=n*m-k;
		int x=0; //rounds main, c problems
		int y=0; //rounds additional, d problems
		int ymax=minfinalists;
		int minscore=Integer.MAX_VALUE;
		if (k>=n*m)
		{
			minscore=0;
			minfinalists=0;
			ymax=-1;
		}
		for (int i=0;i<ymax+1;i++)
		{
			y=i;
			x=(int)Math.ceil((float)(minfinalists-y)/n);
			minscore=Math.min(x*c + y*d,  minscore);
		}
		System.out.println(minscore);
	}

}

import java.io.*;
public class Main
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader input = new BufferedReader ( new InputStreamReader ( System.in ) ) ;
		String I = input.readLine() ;
		int c = Integer.parseInt(I.split(" ")[0]) , d = Integer.parseInt(I.split(" ")[1]) ;
		I = input.readLine() ;
		int n = Integer.parseInt(I.split(" ")[0]) , m = Integer.parseInt(I.split(" ")[1]) ;
		int k = Integer.parseInt(input.readLine()) ;
		int x = n * m - k ;
		int ans = 0 ;
		if ( x > 0 )
			ans = x/n * Math.min(c,d*n) + Math.min((x%n)*d,c);
		System.out.println(ans) ;
	}
}

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

public class Main implements Runnable {
  final boolean isFileIO = false;
  BufferedReader in;
  PrintWriter out;
  StringTokenizer st = new StringTokenizer("");
  String delim = " ";

  public static void main(String[] args) {
    new Thread(null, new Main(), "", 268435456).start();
  }

  public void run() {
    try {
      initIO();
      solve();
      out.close();
    } catch(Exception e) {
      e.printStackTrace(System.err);
      System.exit(-1);
    }
  }

  public void initIO() throws IOException {
    if(!isFileIO) {
      in = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);
    } else {
      in = new BufferedReader(new FileReader("input.txt"));
      out = new PrintWriter("output.txt");
    }
  }

  String nextToken() throws IOException {
    if(!st.hasMoreTokens()) {
      st = new StringTokenizer(in.readLine());
    }
    return st.nextToken(delim);
  }

  String readLine() throws IOException {
    return in.readLine();
  }

  int nextInt() throws IOException {
   return Integer.parseInt(nextToken());
  }

  long nextLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  double nextDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  void solve() throws IOException {
    int c, d, n, m, k;
    c = nextInt(); d = nextInt(); n = nextInt(); m = nextInt(); k = nextInt();
    int cur = n * m - k;
    int ans = 0;
    while(cur > 0) {
      int f = c;
      int s = Math.min(n, cur) * d;
      ans += Math.min(f, s);
      cur -= n;
    }
    out.println(ans);
  }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class RCC_A {
    public static void main(String[] args) throws Exception {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] l = bf.readLine().split(" ");
        int c = Integer.parseInt(l[0]);
        int d = Integer.parseInt(l[1]);
        l = bf.readLine().split(" ");
        int n = Integer.parseInt(l[0]);
        int m = Integer.parseInt(l[1]);
        int k = Integer.parseInt(bf.readLine());
        int minUsed = Integer.MAX_VALUE;
        for (int main = 0; main <= 10000; main++) {
            for (int add = 0; add <= 10000; add++) {
                if ((main / c) * n + (add / d) + k >= n * m) {
                    minUsed = Math.min(minUsed, main + add);
                }
            }
        }
        System.out.println(minUsed);
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        try {
            if (new File("input.txt").exists())
                System.setIn(new FileInputStream("input.txt"));
        } catch (SecurityException e) {
        }
        new Main().run();
    }

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st = new StringTokenizer("");

    private void run() throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        in.close();
        out.close();
    }

    private void solve() throws IOException {
        int c = nextInt(),d = nextInt(), n = nextInt(), m = nextInt(),
                k = nextInt();
        int a = n * m - k;
        if(a <= 0)
            out.println(0);
        else {
            if(d * n <= c)
                out.println(a * d);
            else {
                int ans = (a / n) * c;
                a = a % n;
                if(d*a < c)
                    ans += d*a;
                else
                    ans += c;
                out.println(ans);
            }
        }
    }

    String nextToken() throws IOException {
        while (!st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }
    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }
    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
    String nextLine() throws IOException {
        st = new StringTokenizer("");
        return in.readLine();
    }
    boolean EOF() throws IOException {
        while (!st.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null)
                return true;
            st = new StringTokenizer(s);
        }
        return false;
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (s.hasNextInt()) {
            int c = s.nextInt();
            int d = s.nextInt();
            int n = s.nextInt();
            int m = s.nextInt();
            int k = s.nextInt();

            int num = 0;
            int numNeed = n * m - k;

            if (numNeed > 0) {
                if (c < d * n) {
                    num += c * (numNeed / n);
                    int numOst = numNeed % n;
                    num += Math.min(numOst * d, c);
                } else {
                    num += numNeed * d;
                }
            } else {
                numNeed = 0;
            }

            System.out.print(num);
        }
        s.close();
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class A {
    public static void main(String[] args) throws IOException {
        BufferedReader input =
			new BufferedReader(new InputStreamReader(System.in));
		String[] cd = input.readLine().split(" ");
		String[] nm = input.readLine().split(" ");
		int k = Integer.parseInt(input.readLine());
		int c = Integer.parseInt(cd[0]);
		int d = Integer.parseInt(cd[1]);
		int n = Integer.parseInt(nm[0]);
		int m = Integer.parseInt(nm[1]);
		int s = n*m - k;
		if (s < 0) s = 0;
		int min = Integer.MAX_VALUE;
		for (int i = 0; i <= s/n + 1; i++) {
		    if (min > i * c + Math.max(s - i*n,0) * d)
		        min = i * c + Math.max(s - i*n,0) * d;
		}
		System.out.println(min);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class A
{

    public static void main(String[] args)
    {
        MyScanner in = new MyScanner();

        int c = in.nextInt(); // cost of primary
        int d = in.nextInt(); // cost of secondary

        int n = in.nextInt(); // num per primary
        int m = in.nextInt(); // part of total

        int k = in.nextInt(); // guaranteed

        int needed = n * m;
        needed -= k;

        int ans = 0;

        while (needed > 0)
        {

            int primaryCost = c;
            int secondaryCost = Math.min(n, needed) * d;

            if (primaryCost < secondaryCost)
            {
                ans += primaryCost;
                needed -= n;
            }
            else
            {
                ans += secondaryCost;
                needed -= Math.min(n, needed);
            }

        }

        System.out.println(ans);

    }

    public static void solve(String line)
    {
    }

    public static class Pair
        implements Comparable<Pair>
    {
        int x, y;

        public Pair(int x, int y)
        {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(Pair o)
        {
            return Integer.compare(this.x, o.x);
        }

        @Override
        public int hashCode()
        {
            return x ^ y;
        }

        @Override
        public boolean equals(Object o)
        {
            Pair p = (Pair)o;
            return p.x == x && p.y == y;
        }

    }

    //-----------MyScanner class for faster input----------
    public static class MyScanner
    {
        BufferedReader  br;
        StringTokenizer st;

        public MyScanner()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    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)
            {
                e.printStackTrace();
            }
            return str;
        }

    }
    //--------------------------------------------------------
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.Map.Entry;

public class Main {
	public static void main(String[] args) throws IOException {
		(new Main()).solve();
	}

	public Main() {
	}

	MyReader in = new MyReader();
	PrintWriter out = new PrintWriter(System.out);

	void solve() throws IOException {
		//BufferedReader in = new BufferedReader(new
		//InputStreamReader(System.in));
		//Scanner in = new Scanner(System.in);
		Locale.setDefault(Locale.US);
		//Scanner in = new Scanner(new FileReader("input.in"));
		//PrintWriter out = new PrintWriter("output.txt");
		int c = in.nextInt();
		int d = in.nextInt();
		int n = in.nextInt();
		int m = in.nextInt();
		int k = in.nextInt();
		int count = n * m - k;
		int res = 0;
		while (count > 0) {
			if (count > n) {
				if (c < d * n) {
					count -= n;
					res += c;
				} else {
					count--;
					res += d;
				}
			} else {
				if (c < d * count) {
					count = 0;
					res += c;
				} else {
					count--;
					res += d;
				}
			}
		}
		out.println(res);
		out.close();
	}

	class MyReader {
		private BufferedReader in;
		String[] parsed;
		int index = 0;

		public MyReader() {
			in = new BufferedReader(new InputStreamReader(System.in));
		}

		public int nextInt() throws NumberFormatException, IOException {
			if (parsed == null || parsed.length == index) {
				read();
			}
			return Integer.parseInt(parsed[index++]);
		}

		public long nextLong() throws NumberFormatException, IOException {
			if (parsed == null || parsed.length == index) {
				read();
			}
			return Long.parseLong(parsed[index++]);
		}

		public double nextDouble() throws NumberFormatException, IOException {
			if (parsed == null || parsed.length == index) {
				read();
			}
			return Double.parseDouble(parsed[index++]);
		}

		public String nextString() throws IOException {
			if (parsed == null || parsed.length == index) {
				read();
			}
			return parsed[index++];
		}

		private void read() throws IOException {
			parsed = in.readLine().split(" ");
			index = 0;
		}

		public String readLine() throws IOException {
			return in.readLine();
		}

		public int read(char[] cbuf) throws IOException {
			return in.read(cbuf);
		}
	}

};

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
	  Scanner sc = new Scanner(System.in);

	   int c = sc.nextInt();
	   int d = sc.nextInt();
	   int n = sc.nextInt();
	   int m = sc.nextInt();
	   int k = sc.nextInt();

	   int req = (n*m)-k;

	   if(req <= 0){
	       System.out.println(0);
	       return;
	   }

	   int d1 = req/n;
	    if(req%n != 0)d1++;

	    int a1 = d1*c;

	    int d2 = req/n;
	    int a2 = d2*c;
	    int r = req%n;
	   a2 += r*d;
	   int a3 = d*req;
	   int min1 = Math.min(a1,a2);
	   min1 = Math.min(min1,a3);
	   System.out.println(min1);
	}
}

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.StringTokenizer;

public class Main {
	// in.next() in.nextInt()
	// int n = in.nextInt(); for (int i = 0; i < n; i++) a[i] = in.nextInt();
	// for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = in.nextInt();
	public static long mod = 1000000000 + 7;
	public static void main(String[] args) throws IOException {
	    InputReader in = new InputReader(System.in);
	    PrintWriter out = new PrintWriter(System.out);
	    int c = in.nextInt(); int d = in.nextInt();
	    int n = in.nextInt(); int m = in.nextInt();
	    int k = in.nextInt();
	    int need = n * m - k;
	    int sum = Integer.MAX_VALUE;
	    for (int i = 0; i <= m; i++) {
	    	int p = i * n;
	    	int tasks = i * c + Math.max(0, (need - p)) * d;
	    	sum = Math.min(sum, tasks);
	    }
	    out.println(sum);
	    out.close();
	}
}
class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;

	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream));
		tokenizer = null;
	}
	public String nextLine() throws IOException {
		return reader.readLine();
	}
	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author rabeckiy
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int need = n*m - k;
        if(need <= 0)
            out.println(0);
        else {
            int o = c*((int)Math.ceil((double)need/n));
            int o_and_d = c*(int)Math.floor((double)need/n)+d*(need%n);
            int dop = d*need;
            out.println(Math.min(o, Math.min(o_and_d, dop)));
        }
    }
}

import java.util.*;
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;

public class A
{
    FastScanner in;
    PrintWriter out;

    public void solve() throws IOException
    {
        int c = in.nextInt();
        int d = in.nextInt();

        int n = in.nextInt();
        int m = in.nextInt();

        int k = in.nextInt();

        int ret  = 0;
        int kolD = d * n;

        int ost = n * m - k;

        if(ost > 0)
        {
            int kol = ost / n;

            if(kolD > c)
                ret += kol * c;
            else
                ret += kol * kolD;

            ost -= kol * n;

            int a = ost * d;

            if(a > c)
                ret += c;
            else
                ret += a;
        }

        out.println(ret);
    }

    public void run()
    {
        try
        {
            in  = new FastScanner();
            out = new PrintWriter(System.out);

            solve();

            out.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    class FastScanner
    {
        BufferedReader  br;
        StringTokenizer st;

        FastScanner()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            }
            catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        String nextLine()
        {
            String ret = null;
            try
        {
                ret = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }

            return ret;
        }

        String next()
        {
            while (st == null || !st.hasMoreTokens())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        int[] nextIntArray(int size)
        {
            int[] array = new int[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextInt();
            }

            return array;
        }

        long[] nextLongArray(int size)
        {
            long[] array = new long[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextLong();
            }

            return array;
        }

        BigInteger nextBigInteger()
        {
            return new BigInteger(next());
        }

        Point nextIntPoint()
        {
            int x = nextInt();
            int y = nextInt();
            return new Point(x, y);
        }

        Point[] nextIntPointArray(int size)
        {
            Point[] array = new Point[size];

            for (int index = 0; index < size; ++index)
            {
                array[index] = nextIntPoint();
            }

            return array;
        }

        List<Integer>[] readGraph(int vertexNumber, int edgeNumber, boolean undirected)
        {
            List<Integer>[] graph = new List[vertexNumber];

            for (int index = 0; index < vertexNumber; ++index)
            {
                graph[index] = new ArrayList<Integer>();
            }

            while (edgeNumber-- > 0)
            {
                int from = nextInt() - 1;
                int to   = nextInt() - 1;

                graph[from].add(to);

                if(undirected)
                    graph[to].add(from);
            }

            return graph;
        }
    }

    public static void main(String[] arg)
    {
        new A().run();
    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import javax.management.RuntimeErrorException;

public class Template implements Runnable {

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	void init() throws FileNotFoundException {
		try {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		} catch (Exception e) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		}
	}

	class GraphBuilder {
		int n, m;
		int[] x, y;
		int index;
		int[] size;

		GraphBuilder(int n, int m) {
			this.n = n;
			this.m = m;
			x = new int[m];
			y = new int[m];
			size = new int[n];
		}

		void add(int u, int v) {
			x[index] = u;
			y[index] = v;
			size[u]++;
			size[v]++;
			index++;
		}

		void addDir(int u, int v) {
			x[index] = u;
			y[index] = v;
			size[u]++;
			index++;
		}

		int[][] buildDir() {
			int[][] graph = new int[n][];
			for (int i = 0; i < n; i++) {
				graph[i] = new int[size[i]];
			}
			for (int i = m - 1; i >= 0; i--) {
				graph[x[i]][--size[x[i]]] = y[i];
			}
			return graph;
		}

		int[][] build() {
			int[][] graph = new int[n][];
			for (int i = 0; i < n; i++) {
				graph[i] = new int[size[i]];
			}
			for (int i = m - 1; i >= 0; i--) {
				graph[x[i]][--size[x[i]]] = y[i];
				graph[y[i]][--size[y[i]]] = x[i];
			}
			return graph;
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			try {
				tok = new StringTokenizer(in.readLine());
			} catch (Exception e) {
				return null;
			}
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	int[] readIntArray(int size) throws IOException {
		int[] res = new int[size];
		for (int i = 0; i < size; i++) {
			res[i] = readInt();
		}
		return res;
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	<T> List<T>[] createGraphList(int size) {
		List<T>[] list = new List[size];
		for (int i = 0; i < size; i++) {
			list[i] = new ArrayList<>();
		}
		return list;
	}

	public static void main(String[] args) {
		new Template().run();
		// new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
	}

	long timeBegin, timeEnd;

	void time() {
		timeEnd = System.currentTimeMillis();
		System.err.println("Time = " + (timeEnd - timeBegin));
	}

	long memoryTotal, memoryFree;

	void memory() {
		memoryFree = Runtime.getRuntime().freeMemory();
		System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10) + " KB");
	}

	public void run() {
		try {
			timeBegin = System.currentTimeMillis();
			memoryTotal = Runtime.getRuntime().freeMemory();
			init();
			solve();
			out.close();
			if (System.getProperty("ONLINE_JUDGE") == null) {
				time();
				memory();
			}
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(-1);
		}
	}

	void solve() throws IOException {
		int c = readInt();
		int d = readInt();

		int n = readInt();
		int m = readInt();

		int k = readInt();

		int need = n * m - k;

		int min = Integer.MAX_VALUE;
		for (int count = 0;;count++) {
			int cost = count * c;
			int ost = Math.max(0, need - count * n);
			cost += ost * d;
			min = Math.min(min, cost);
			if (count * n >= need) break;
		}
		out.println(min);

	}

}

/**
 * @author panicker
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class ProblemB {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }
}

class Task {

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt(), d = in.nextInt(), n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
        int minPersons = n * m - k;
        if (minPersons <= 0) {
            out.print(0);
        } else {

            int dp[] = new int[minPersons + 1];

            dp[1] = Math.min(c, d);
            for (int i = 1; i <= minPersons; i++) {
                for (int j = 1; j < i; ++j) {
                    if (i - n < 0)
                        dp[i] = Math.min(Math.min(dp[j] + dp[i - j], dp[i - 1] + d), c);
                    else
                        dp[i] = Math.min(Math.min(dp[j] + dp[i - j], dp[i - 1] + d), c + dp[i - n]);
                }
                // out.print(dp[i]);
            }
            out.print(dp[minPersons]);
        }
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

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

import static java.lang.Math.*;

public class Solution implements Runnable {

	public void solve() throws Exception {
		int c = sc.nextInt();
		int d = sc.nextInt();
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		int ans = Integer.MAX_VALUE;
		for (int i = 0; i < m + 1; i++) {
			int j = n * (m - i) - k;
			j = max(j, 0);
			ans = min(ans, i * c + j * d);
		}
		out.println(ans);
	}

	static Throwable throwable;

	BufferedReader in;
	PrintWriter out;
	FastScanner sc;

	public static void main(String[] args) throws Throwable {
		Thread thread = new Thread(null, new Solution(), "", (1 << 26));
		thread.start();
		thread.join();
		if (throwable != null) {
			throw throwable;
		}
	}

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			//in = new BufferedReader(new FileReader(""));
			//out = new PrintWriter("");
			sc = new FastScanner(in);
			solve();
		} catch (Throwable throwable) {
			this.throwable = throwable;
		} finally {
			out.close();
		}
	}

}

class FastScanner {
	BufferedReader reader;
	StringTokenizer strTok;

	public FastScanner(BufferedReader reader) {
		this.reader = reader;
	}

	public String nextToken() throws Exception {
		while (strTok == null || !strTok.hasMoreTokens()) {
			strTok = new StringTokenizer(reader.readLine());
		}
		return strTok.nextToken();
	}

	public int nextInt() throws Exception {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws Exception {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws Exception {
		return Double.parseDouble(nextToken());
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class First {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();

        int totalRemParticipants = n * m - k;
        if (totalRemParticipants <= 0) {
            out.println('0');
            return;
        }
        int ans = 0;
        if (c <= n * d) {
            if (totalRemParticipants % n == 0) {
                ans = (totalRemParticipants / n) * c;
            } else {
                int rem = Math.abs((totalRemParticipants - n) % n);
                ans = Math.min( (totalRemParticipants / n) * c + c, (totalRemParticipants / n) * c + d * rem);

            }
        }  else {
            ans = d * totalRemParticipants;
        }
        out.println(ans);
    }
}
class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public String nextLine() {
        String inputLine = "";
        try {
            inputLine = reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return inputLine;
    }
}

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

public class SolutionA {
	public void solve(){
		int firstRound = nextInt(), secondRound = nextInt();
		int n = nextInt(), m = nextInt();
		int k = nextInt();
		int needs = n * m - k;
		int[] ans = new int[100000];
		Arrays.fill(ans, -1);
		ans[0] = 0;
		for(int i = n ; i < 100000 ; i+=n){
			ans[i] = ans[i-n] + firstRound;
		}
		for(int i = 1 ; i < 100000 ; i++)
			if(ans[i] == -1) ans[i] = ans[i-1] + secondRound;
			else ans[i] = Math.min(ans[i-1] + secondRound , ans[i]);
		int res = Integer.MAX_VALUE;
		for(int i = Math.max(0, needs) ; i < 100000 ; i++) if(ans[i]!=-1) res = Math.min(res, ans[i]);
		out.println(res);

	}

	public void run(){
		solve();
		out.close();
	}
	public static void main(String args[]){
		new SolutionA().run();
	}
	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	PrintWriter out = new PrintWriter(System.out);
	String line;
	StringTokenizer st;
	public String nextLine(){
		try {
			line = bf.readLine();
			st = new StringTokenizer(line);
		} catch (IOException e) {
			return null;
		}
		return line;
	}
	public String nextString(){
		while (st == null || !st.hasMoreElements()) {
            try {
                line = bf.readLine();
                st = new StringTokenizer(line);
            } catch (IOException e) {
                return null;
            }
        }
        return st.nextToken();
	}
	public int nextInt(){
		return Integer.parseInt(nextString());
	}
	public long nextLong(){
		return Long.parseLong(nextString());
	}
	public double nextDouble(){
		return Double.parseDouble(nextString());
	}
}

import java.awt.*;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.util.List;
import java.util.Queue;

import static java.lang.Math.max;
import static java.lang.Math.min;

public class A implements Runnable{

    // SOLUTION!!!
    // HACK ME PLEASE IF YOU CAN!!!
    // PLEASE!!!
    // PLEASE!!!
    // PLEASE!!!

    private final static Random rnd = new Random();
    private final static String fileName = "";

    private final static long MODULO = 1000 * 1000 * 1000 + 7;

    private void solve() {
    	int bigContest = readInt();
    	int smallContest = readInt();

    	int bigLimit = readInt();
    	int coeff = readInt();

    	int already = readInt();

    	int need = bigLimit * coeff - already;

    	int answer = Integer.MAX_VALUE;
    	for (int i = 0; i <= coeff; ++i) {
    		int bigAlready = bigLimit * i;
    		int smallAlready = max(0, need - bigAlready);

    		answer = min(answer, i * bigContest + smallAlready * smallContest);
    	}
    	out.println(answer);
    }

    /////////////////////////////////////////////////////////////////////

    private static long add(long a, long b) { return (a + b) % MODULO; }
    private static long subtract(long a, long b) { return add(a, MODULO - b) % MODULO; }
    private static long mult(long a, long b) { return (a * b) % MODULO; }

    /////////////////////////////////////////////////////////////////////

    private final static boolean FIRST_INPUT_STRING = false;
    private final static boolean MULTIPLE_TESTS = true;
    private final boolean ONLINE_JUDGE = !new File("input.txt").exists();
//    private final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    private final static int MAX_STACK_SIZE = 128;

    private final static boolean OPTIMIZE_READ_NUMBERS = false;

    /////////////////////////////////////////////////////////////////////

    public void run(){
        try{
            timeInit();
            Locale.setDefault(Locale.US);

            init();

            if (ONLINE_JUDGE) {
                solve();
            } else {
                do {
                    try {
                        timeInit();
                        solve();
                        time();

                        out.println();
                    } catch (NumberFormatException e) {
                        break;
                    } catch (NullPointerException e) {
                        if (FIRST_INPUT_STRING) break;
                        else throw e;
                    }
                } while (MULTIPLE_TESTS);
            }

            out.close();
            time();
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private BufferedReader in;
    private OutputWriter out;
    private StringTokenizer tok = new StringTokenizer("");

    public static void main(String[] args){
        new Thread(null, new A(), "", MAX_STACK_SIZE * (1L << 20)).start();
    }

    /////////////////////////////////////////////////////////////////////

    private void init() throws FileNotFoundException{
        Locale.setDefault(Locale.US);

        if (ONLINE_JUDGE){
            if (fileName.isEmpty()) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new OutputWriter(System.out);
            } else {
                in = new BufferedReader(new FileReader(fileName + ".in"));
                out = new OutputWriter(fileName + ".out");
            }
        }else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new OutputWriter("output.txt");
        }
    }

    ////////////////////////////////////////////////////////////////

    private long timeBegin;

    private void timeInit() {
        this.timeBegin = System.currentTimeMillis();
    }

    private void time(){
        long timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    private void debug(Object... objects){
        if (ONLINE_JUDGE){
            for (Object o: objects){
                System.err.println(o.toString());
            }
        }
    }

    /////////////////////////////////////////////////////////////////////

    private String delim = " ";

    private String readLine() {
        try {
            return in.readLine();
        } catch (IOException e) {
            throw new RuntimeIOException(e);
        }
    }

    private String readString() {
        try {
            while(!tok.hasMoreTokens()){
                tok = new StringTokenizer(readLine(), delim);
            }

            return tok.nextToken(delim);
        } catch (NullPointerException e) {
            return null;
        }
    }

    /////////////////////////////////////////////////////////////////

    private final char NOT_A_SYMBOL = '\0';

    private char readChar() {
        try {
            int intValue = in.read();

            if (intValue == -1){
                return NOT_A_SYMBOL;
            }

            return (char) intValue;
        } catch (IOException e) {
            throw new RuntimeIOException(e);
        }
    }

    private char[] readCharArray() {
        return readLine().toCharArray();
    }

    private char[][] readCharField(int rowsCount) {
        char[][] field = new char[rowsCount][];
        for (int row = 0; row < rowsCount; ++row) {
            field[row] = readCharArray();
        }

        return field;
    }

    /////////////////////////////////////////////////////////////////

    private long optimizedReadLong() {
        int sign = 1;
        long result = 0;
        boolean started = false;
        while (true) {
            try {
                int j = in.read();
                if (-1 == j) {
                    if (started) return sign * result;
                    throw new NumberFormatException();
                }

                if (j == '-') {
                    if (started) throw new NumberFormatException();
                    sign = -sign;
                }

                if ('0' <= j && j <= '9') {
                    result = result * 10 + j - '0';
                    started = true;
                } else if (started) {
                    return sign * result;
                }
            } catch (IOException e) {
                throw new RuntimeIOException(e);
            }
        }
    }

    private int readInt() {

        if (!OPTIMIZE_READ_NUMBERS) {
            return Integer.parseInt(readString());
        } else {
            return (int) optimizedReadLong();
        }
    }

    private int[] readIntArray(int size) {
        int[] array = new int[size];

        for (int index = 0; index < size; ++index){
            array[index] = readInt();
        }

        return array;
    }

    private int[] readSortedIntArray(int size) {
        Integer[] array = new Integer[size];

        for (int index = 0; index < size; ++index) {
            array[index] = readInt();
        }
        Arrays.sort(array);

        int[] sortedArray = new int[size];
        for (int index = 0; index < size; ++index) {
            sortedArray[index] = array[index];
        }

        return sortedArray;
    }

    private int[] readIntArrayWithDecrease(int size) {
        int[] array = readIntArray(size);

        for (int i = 0; i < size; ++i) {
            array[i]--;
        }

        return array;
    }

    ///////////////////////////////////////////////////////////////////

    private int[][] readIntMatrix(int rowsCount, int columnsCount) {
        int[][] matrix = new int[rowsCount][];

        for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
            matrix[rowIndex] = readIntArray(columnsCount);
        }

        return matrix;
    }

    private int[][] readIntMatrixWithDecrease(int rowsCount, int columnsCount) {
        int[][] matrix = new int[rowsCount][];

        for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
            matrix[rowIndex] = readIntArrayWithDecrease(columnsCount);
        }

        return matrix;
    }

    ///////////////////////////////////////////////////////////////////

    private long readLong() {
        if (!OPTIMIZE_READ_NUMBERS) {
            return Long.parseLong(readString());
        } else {
            return optimizedReadLong();
        }
    }

    private long[] readLongArray(int size) {
        long[] array = new long[size];

        for (int index = 0; index < size; ++index){
            array[index] = readLong();
        }

        return array;
    }

    ////////////////////////////////////////////////////////////////////

    private double readDouble() {
        return Double.parseDouble(readString());
    }

    private double[] readDoubleArray(int size) {
        double[] array = new double[size];

        for (int index = 0; index < size; ++index){
            array[index] = readDouble();
        }

        return array;
    }

    ////////////////////////////////////////////////////////////////////

    private BigInteger readBigInteger() {
        return new BigInteger(readString());
    }

    private BigDecimal readBigDecimal() {
        return new BigDecimal(readString());
    }

    /////////////////////////////////////////////////////////////////////

    private Point readPoint() {
        int x = readInt();
        int y = readInt();
        return new Point(x, y);
    }

    private Point[] readPointArray(int size) {
        Point[] array = new Point[size];

        for (int index = 0; index < size; ++index){
            array[index] = readPoint();
        }

        return array;
    }

    /////////////////////////////////////////////////////////////////////

    @Deprecated
    private List<Integer>[] readGraph(int vertexNumber, int edgeNumber) {
        @SuppressWarnings("unchecked")
        List<Integer>[] graph = new List[vertexNumber];

        for (int index = 0; index < vertexNumber; ++index){
            graph[index] = new ArrayList<Integer>();
        }

        while (edgeNumber-- > 0){
            int from = readInt() - 1;
            int to = readInt() - 1;

            graph[from].add(to);
            graph[to].add(from);
        }

        return graph;
    }

    private static class GraphBuilder {

        final int size;
        final List<Integer>[] edges;

        static GraphBuilder createInstance(int size) {
            List<Integer>[] edges = new List[size];
            for (int v = 0; v < size; ++v) {
                edges[v] = new ArrayList<Integer>();
            }

            return new GraphBuilder(edges);
        }

        private GraphBuilder(List<Integer>[] edges) {
            this.size = edges.length;
            this.edges = edges;
        }

        public void addEdge(int from, int to) {
            addDirectedEdge(from, to);
            addDirectedEdge(to, from);
        }

        public void addDirectedEdge(int from, int to) {
            edges[from].add(to);
        }

        public int[][] build() {
            int[][] graph = new int[size][];
            for (int v = 0; v < size; ++v) {
                List<Integer> vEdges = edges[v];
                graph[v] = castInt(vEdges);
            }

            return graph;
        }
    }

    private final static int ZERO_INDEXATION = 0, ONE_INDEXATION = 1;

    private int[][] readUnweightedGraph(int vertexNumber, int edgesNumber) {
        return readUnweightedGraph(vertexNumber, edgesNumber, ONE_INDEXATION, false);
    }

    private int[][] readUnweightedGraph(int vertexNumber, int edgesNumber,
                                        int indexation, boolean directed
    ) {
        GraphBuilder graphBuilder = GraphBuilder.createInstance(vertexNumber);
        for (int i = 0; i < edgesNumber; ++i) {
            int from = readInt() - indexation;
            int to = readInt() - indexation;

            if (directed) graphBuilder.addDirectedEdge(from, to);
            else graphBuilder.addEdge(from, to);
        }

        return graphBuilder.build();
    }

    private static class Edge {
        int to;
        int w;

        Edge(int to, int w) {
            this.to = to;
            this.w = w;
        }
    }

    private Edge[][] readWeightedGraph(int vertexNumber, int edgesNumber) {
        return readWeightedGraph(vertexNumber, edgesNumber, ONE_INDEXATION, false);
    }

    private Edge[][] readWeightedGraph(int vertexNumber, int edgesNumber,
                                       int indexation, boolean directed) {
        @SuppressWarnings("unchecked")
        List<Edge>[] graph = new List[vertexNumber];
        for (int v = 0; v < vertexNumber; ++v) {
            graph[v] = new ArrayList<Edge>();
        }

        while (edgesNumber --> 0) {
            int from = readInt() - indexation;
            int to = readInt() - indexation;
            int w = readInt();

            graph[from].add(new Edge(to, w));
            if (!directed) graph[to].add(new Edge(from, w));
        }

        Edge[][] graphArrays = new Edge[vertexNumber][];
        for (int v = 0; v < vertexNumber; ++v) {
            graphArrays[v] = graph[v].toArray(new Edge[0]);
        }

        return graphArrays;
    }

    /////////////////////////////////////////////////////////////////////

    private static class IntIndexPair {

        static Comparator<IntIndexPair> increaseComparator = new Comparator<IntIndexPair>() {

            @Override
            public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
                int value1 = indexPair1.value;
                int value2 = indexPair2.value;

                if (value1 != value2) return value1 - value2;

                int index1 = indexPair1.index;
                int index2 = indexPair2.index;

                return index1 - index2;
            }
        };

        static Comparator<IntIndexPair> decreaseComparator = new Comparator<IntIndexPair>() {

            @Override
            public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
                int value1 = indexPair1.value;
                int value2 = indexPair2.value;

                if (value1 != value2) return -(value1 - value2);

                int index1 = indexPair1.index;
                int index2 = indexPair2.index;

                return index1 - index2;
            }
        };

        static IntIndexPair[] from(int[] array) {
            IntIndexPair[] iip = new IntIndexPair[array.length];
            for (int i = 0; i < array.length; ++i) {
                iip[i] = new IntIndexPair(array[i], i);
            }

            return iip;
        }

        int value, index;

        IntIndexPair(int value, int index) {
            super();
            this.value = value;
            this.index = index;
        }

        int getRealIndex() {
            return index + 1;
        }
    }

    private IntIndexPair[] readIntIndexArray(int size) {
        IntIndexPair[] array = new IntIndexPair[size];

        for (int index = 0; index < size; ++index) {
            array[index] = new IntIndexPair(readInt(), index);
        }

        return array;
    }

    /////////////////////////////////////////////////////////////////////

    private static class OutputWriter extends PrintWriter {

        final int DEFAULT_PRECISION = 12;

        private int precision;
        private String format, formatWithSpace;

        {
            precision = DEFAULT_PRECISION;

            format = createFormat(precision);
            formatWithSpace = format + " ";
        }

        OutputWriter(OutputStream out) {
            super(out);
        }

        OutputWriter(String fileName) throws FileNotFoundException {
            super(fileName);
        }

        int getPrecision() {
            return precision;
        }

        void setPrecision(int precision) {
            precision = max(0, precision);
            this.precision = precision;

            format = createFormat(precision);
            formatWithSpace = format + " ";
        }

        String createFormat(int precision){
            return "%." + precision + "f";
        }

        @Override
        public void print(double d){
            printf(format, d);
        }

        void printWithSpace(double d){
            printf(formatWithSpace, d);
        }

        void printAll(double...d){
            for (int i = 0; i < d.length - 1; ++i){
                printWithSpace(d[i]);
            }

            print(d[d.length - 1]);
        }

        @Override
        public void println(double d){
            printlnAll(d);
        }

        void printlnAll(double... d){
            printAll(d);
            println();
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class RuntimeIOException extends RuntimeException {

        /**
         *
         */
        private static final long serialVersionUID = -6463830523020118289L;

        RuntimeIOException(Throwable cause) {
            super(cause);
        }
    }

    /////////////////////////////////////////////////////////////////////
    //////////////// Some useful constants andTo functions ////////////////
    /////////////////////////////////////////////////////////////////////

    private static final int[][] steps = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    private static final int[][] steps8 = {
            {-1, 0}, {1, 0}, {0, -1}, {0, 1},
            {-1, -1}, {1, 1}, {1, -1}, {-1, 1}
    };

    private static boolean checkCell(int row, int rowsCount, int column, int columnsCount) {
        return checkIndex(row, rowsCount) && checkIndex(column, columnsCount);
    }

    private static boolean checkIndex(int index, int lim){
        return (0 <= index && index < lim);
    }

    /////////////////////////////////////////////////////////////////////

    private static int getBit(long mask, int bit) { return (int)((mask >> bit) & 1); }
    private static boolean checkBit(long mask, int bit){
        return getBit(mask, bit) != 0;
    }

    /////////////////////////////////////////////////////////////////////

    private static long getSum(int[] array) {
        long sum = 0;
        for (int value: array) {
            sum += value;
        }

        return sum;
    }

    private static Point getMinMax(int[] array) {
        int min = array[0];
        int max = array[0];

        for (int index = 0, size = array.length; index < size; ++index, ++index) {
            int value = array[index];

            if (index == size - 1) {
                min = min(min, value);
                max = max(max, value);
            } else {
                int otherValue = array[index + 1];

                if (value <= otherValue) {
                    min = min(min, value);
                    max = max(max, otherValue);
                } else {
                    min = min(min, otherValue);
                    max = max(max, value);
                }
            }
        }

        return new Point(min, max);
    }

    /////////////////////////////////////////////////////////////////////

    private static int[] getPrimes(int n) {
        boolean[] used = new boolean[n];
        used[0] = used[1] = true;

        int size = 0;
        for (int i = 2; i < n; ++i) {
            if (!used[i]) {
                ++size;
                for (int j = 2 * i; j < n; j += i) {
                    used[j] = true;
                }
            }
        }

        int[] primes = new int[size];
        for (int i = 0, cur = 0; i < n; ++i) {
            if (!used[i]) {
                primes[cur++] = i;
            }
        }

        return primes;
    }

    /////////////////////////////////////////////////////////////////////

    int[] getDivisors(int value) {
        List<Integer> divisors = new ArrayList<Integer>();
        for (int divisor = 1; divisor * divisor <= value; ++divisor) {
            if (value % divisor == 0) {
                divisors.add(divisor);
                if (divisor * divisor != value) {
                    divisors.add(value / divisor);
                }
            }
        }

        return castInt(divisors);
    }

    /////////////////////////////////////////////////////////////////////

    private static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    private static long gcd(long a, long b) {
        return (a == 0 ? b : gcd(b % a, a));
    }

/////////////////////////////////////////////////////////////////////

    private interface MultiSet<ValueType> {

        int size();

        void inc(ValueType value);
        boolean dec(ValueType value);

        int count(ValueType value);
    }

    private static abstract class MultiSetImpl
            <ValueType, MapType extends Map<ValueType, Integer>>
            implements MultiSet<ValueType> {

        protected final MapType map;
        protected int size;

        protected MultiSetImpl(MapType map) {
            this.map = map;
            this.size = 0;
        }

        public int size() {
            return size;
        }

        public void inc(ValueType value) {
            int count = count(value);
            map.put(value, count + 1);

            ++size;
        }

        public boolean dec(ValueType value) {
            int count = count(value);
            if (count == 0) return false;

            if (count == 1) map.remove(value);
            else map.put(value, count - 1);

            --size;
            return true;
        }

        public int count(ValueType value) {
            Integer count = map.get(value);
            return (count == null ? 0 : count);
        }
    }

    private static class HashMultiSet<ValueType>
            extends MultiSetImpl<ValueType, Map<ValueType, Integer>> {

        public static <ValueType> MultiSet<ValueType> createMultiSet() {
            Map<ValueType, Integer> map = new HashMap<ValueType, Integer>();
            return new HashMultiSet<ValueType>(map);
        }

        HashMultiSet(Map<ValueType, Integer> map) {
            super(map);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private interface SortedMultiSet<ValueType> extends MultiSet<ValueType> {

        ValueType min();
        ValueType max();

        ValueType pollMin();
        ValueType pollMax();

        ValueType lower(ValueType value);
        ValueType floor(ValueType value);

        ValueType ceiling(ValueType value);
        ValueType higher(ValueType value);
    }

    private static abstract class SortedMultiSetImpl<ValueType>
            extends MultiSetImpl<ValueType, NavigableMap<ValueType, Integer>>
            implements SortedMultiSet<ValueType> {

        SortedMultiSetImpl(NavigableMap<ValueType, Integer> map) {
            super(map);
        }

        @Override
        public ValueType min() {
            return (size == 0 ? null : map.firstKey());
        }

        @Override
        public ValueType max() {
            return (size == 0 ? null : map.lastKey());
        }

        @Override
        public ValueType pollMin() {
            ValueType first = min();
            if (first != null) dec(first);
            return first;
        }

        @Override
        public ValueType pollMax() {
            ValueType last = max();
            dec(last);
            return last;
        }

        @Override
        public ValueType lower(ValueType value) {
            return map.lowerKey(value);
        }

        @Override
        public ValueType floor(ValueType value) {
            return map.floorKey(value);
        }

        @Override
        public ValueType ceiling(ValueType value) {
            return map.ceilingKey(value);
        }

        @Override
        public ValueType higher(ValueType value) {
            return map.higherKey(value);
        }
    }

    private static class TreeMultiSet<ValueType>
            extends SortedMultiSetImpl<ValueType> {

        public static <ValueType> SortedMultiSet<ValueType> createMultiSet() {
            NavigableMap<ValueType, Integer> map = new TreeMap<ValueType, Integer>();
            return new TreeMultiSet<ValueType>(map);
        }

        TreeMultiSet(NavigableMap<ValueType, Integer> map) {
            super(map);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class IdMap<KeyType> extends HashMap<KeyType, Integer> {

        /**
         *
         */
        private static final long serialVersionUID = -3793737771950984481L;

        public IdMap() {
            super();
        }

        int register(KeyType key) {
            Integer id = super.get(key);
            if (id == null) {
                super.put(key, id = size());
            }

            return id;
        }

        int getId(KeyType key) {
            return get(key);
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class SortedIdMapper<ValueType extends Comparable<ValueType>> {

        private final List<ValueType> values;

        public SortedIdMapper() {
            this.values = new ArrayList<ValueType>();
        }

        void addValue(ValueType value) {
            values.add(value);
        }

        IdMap<ValueType> build() {
            Collections.sort(values);

            IdMap<ValueType> ids = new IdMap<ValueType>();

            for (int index = 0; index < values.size(); ++index) {
                ValueType value = values.get(index);
                if (index == 0 || values.get(index - 1).compareTo(value) != 0) {
                    ids.register(value);
                }
            }

            return ids;
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static int[] castInt(List<Integer> list) {
        int[] array = new int[list.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = list.get(i);
        }

        return array;
    }

    private static long[] castLong(List<Long> list) {
        long[] array = new long[list.size()];
        for (int i = 0; i < array.length; ++i) {
            array[i] = list.get(i);
        }

        return array;
    }

    /////////////////////////////////////////////////////////////////////

    /**
     * Generates list with keys 0..<n
     * @param n - exclusive limit of sequence
     */
    private static List<Integer> order(int n) {
        List<Integer> sequence = new ArrayList<Integer>();
        for (int i = 0; i < n; ++i) {
            sequence.add(i);
        }

        return sequence;
    }

    /////////////////////////////////////////////////////////////////////

    interface Rmq {
        int getMin(int left, int right);
        int getMinIndex(int left, int right);
    }

    private static class SparseTable implements Rmq {

        private static final int MAX_BIT = 20;

        int n;
        int[] array;

        SparseTable(int[] array) {
            this.n = array.length;
            this.array = array;
        }

        int[] lengthMaxBits;
        int[][] table;

        int getIndexOfLess(int leftIndex, int rightIndex) {
            return (array[leftIndex] <= array[rightIndex])
                    ? leftIndex
                    : rightIndex;
        }

        SparseTable build() {
            this.lengthMaxBits = new int[n + 1];
            lengthMaxBits[0] = 0;
            for (int i = 1; i <= n; ++i) {
                lengthMaxBits[i] = lengthMaxBits[i - 1];
                int length = (1 << lengthMaxBits[i]);
                if (length + length <= i) ++lengthMaxBits[i];
            }

            this.table = new int[MAX_BIT][n];
            table[0] = castInt(order(n));

            for (int bit = 0; bit < MAX_BIT - 1; ++bit) {
                for (int i = 0, j = (1 << bit); j < n; ++i, ++j) {
                    table[bit + 1][i] = getIndexOfLess(
                            table[bit][i], table[bit][j]
                    );
                }
            }

            return this;
        }

        @Override
        public int getMinIndex(int left, int right) {
            int length = (right - left + 1);

            int bit = lengthMaxBits[length];
            int segmentLength = (1 << bit);

            return getIndexOfLess(
                    table[bit][left], table[bit][right - segmentLength + 1]
            );
        }

        @Override
        public int getMin(int left, int right) {
            return array[getMinIndex(left, right)];
        }
    }

    private static Rmq createRmq(int[] array) {
        return new SparseTable(array).build();
    }

    /////////////////////////////////////////////////////////////////////

    interface Lca {
        Lca build(int root);
        int lca(int a, int b);

        int height(int v);
    }

    private static class LcaRmq implements Lca {

        int n;
        int[][] graph;

        LcaRmq(int[][] graph) {
            this.n = graph.length;
            this.graph = graph;
        }

        int time;

        int[] order;
        int[] heights;
        int[] first;

        Rmq rmq;

        @Override
        public LcaRmq build(int root) {
            this.order = new int[n + n];
            this.heights = new int[n];

            this.first = new int[n];
            Arrays.fill(first, -1);

            this.time = 0;
            dfs(root, 0);

            int[] orderedHeights = new int[n + n];
            for (int i = 0; i < order.length; ++i) {
                orderedHeights[i] = heights[order[i]];
            }

            this.rmq = createRmq(orderedHeights);
            return this;
        }

        void dfs(int from, int height) {
            first[from] = time;
            order[time] = from;
            heights[from] = height;
            ++time;

            for (int to : graph[from]) {
                if (first[to] == -1) {
                    dfs(to, height + 1);

                    order[time] = from;
                    ++time;
                }
            }
        }

        @Override
        public int lca(int a, int b) {
            int aFirst = first[a], bFirst = first[b];
            int left = min(aFirst, bFirst), right = max(aFirst, bFirst);

            int orderIndex = rmq.getMinIndex(left, right);
            return order[orderIndex];
        }

        @Override
        public int height(int v) {
            return heights[v];
        }
    }

    private static class LcaBinary implements Lca {

        private static final int MAX_BIT = 20;

        int n;
        int[][] graph;

        int[] h;
        int[][] parents;

        LcaBinary(int[][] graph) {
            this.n = graph.length;
            this.graph = graph;
        }

        @Override
        public Lca build(int root) {
            this.h = new int[n];

            this.parents = new int[MAX_BIT][n];
            Arrays.fill(parents[0], -1);

            Queue<Integer> queue = new ArrayDeque<Integer>();

            queue.add(root);
            add(root, root);

            while (queue.size() > 0) {
                int from = queue.poll();
                for (int to : graph[from]) {
                    if (parents[0][to] == -1) {
                        add(from, to);
                        queue.add(to);
                    }
                }
            }

            return this;
        }

        void add(int parent, int v) {
            h[v] = h[parent] + 1;
            parents[0][v] = parent;
            for (int bit = 0; bit < MAX_BIT - 1; ++bit) {
                parents[bit + 1][v] = parents[bit][parents[bit][v]];
            }
        }

        @Override
        public int lca(int a, int b) {
            if (h[a] < h[b]) {
                int tmp = a;
                a = b;
                b = tmp;
            }

            int delta = h[a] - h[b];
            for (int bit = MAX_BIT - 1; bit >= 0; --bit) {
                if (delta >= (1 << bit)) {
                    delta -= (1 << bit);
                    a = parents[bit][a];
                }
            }

            if (a == b) return a;

            for (int bit = MAX_BIT - 1; bit >= 0; --bit) {
                int nextA = parents[bit][a], nextB = parents[bit][b];
                if (nextA != nextB) {
                    a = nextA;
                    b = nextB;
                }
            }

            return parents[0][a];
        }

        @Override
        public int height(int v) {
            return h[v];
        }
    }

    private static Lca createLca(int[][] graph, int root) {
        return new LcaRmq(graph).build(root);
    }

    /////////////////////////////////////////////////////////////////////

    private static class BiconnectedGraph {

        int n;
        int[][] graph;

        BiconnectedGraph(int[][] graph) {
            this.n = graph.length;
            this.graph = graph;
        }

        int time;
        int[] tin, up;

        boolean[] used;

        BiconnectedGraph build() {
            calculateTimes();
            condensateComponents();

            return this;
        }

        void calculateTimes() {
            this.tin = new int[n];
            this.up = new int[n];

            this.time = 0;

            this.used = new boolean[n];
            timeDfs(0, -1);
        }

        void timeDfs(int from, int parent) {
            used[from] = true;

            up[from] = tin[from] = time;
            ++time;

            for (int to : graph[from]) {
                if (to == parent) continue;

                if (used[to]) {
                    up[from] = min(up[from], tin[to]);
                } else {
                    timeDfs(to, from);
                    up[from] = min(up[from], up[to]);
                }
            }
        }

        int[] components;
        int[][] componentsGraph;

        int component(int v) { return components[v]; }

        int[][] toGraph() {
            return componentsGraph;
        }

        void condensateComponents() {
            this.components = new int[n];
            Arrays.fill(components, -1);

            for (int v = 0; v < n; ++v) {
                if (components[v] == -1) {
                    componentsDfs(v, v);
                }
            }

            GraphBuilder graphBuilder = GraphBuilder.createInstance(n);

            Set<Point> edges = new HashSet<Point>();
            for (int from = 0; from < n; ++from) {
                int fromComponent = components[from];

                for (int to : graph[from]) {
                    int toComponent = components[to];
                    if (fromComponent == toComponent) continue;

                    Point edge = new Point(fromComponent, toComponent);
                    if (edges.add(edge)) graphBuilder.addDirectedEdge(fromComponent, toComponent);
                }
            }

            this.componentsGraph = graphBuilder.build();
        }

        void componentsDfs(int from, int color) {
            components[from] = color;
            for (int to : graph[from]) {
                if (components[to] != -1) continue;

                if (tin[from] >= up[to] && tin[to] >= up[from]) {
                    componentsDfs(to, color);
                }
            }
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class VertexBiconnectedGraph {

        static class Edge {
            int to;
            int index;

            Edge(int to, int index) {
                this.to = to;
                this.index = index;
            }
        }

        int n, m;
        List<Edge>[] graph;
        List<Edge> edges;

        VertexBiconnectedGraph(int n) {
            this.n = n;
            this.m = 0;

            this.graph = new List[n];
            for (int v = 0; v < n; ++v) {
                graph[v] = new ArrayList<Edge>();
            }

            this.edges = new ArrayList<Edge>();
        }

        void addEdge(int from, int to) {
            Edge fromToEdge = new Edge(to, m);
            Edge toFromEdge = new Edge(from, m + 1);

            edges.add(fromToEdge);
            edges.add(toFromEdge);

            graph[from].add(fromToEdge);
            graph[to].add(toFromEdge);

            m += 2;
        }

        int time;

        boolean[] used;
        int[] tin, up;
        int[] parents;

        boolean[] isArticulation;

        boolean[] findArticulationPoints() {
            this.isArticulation = new boolean[n];

            this.used = new boolean[n];
            this.parents = new int[n];
            Arrays.fill(parents, -1);

            this.tin = new int[n];
            this.up = new int[n];

            this.time = 0;

            for (int v = 0; v < n; ++v) {
                if (!used[v]) {
                    articulationDfs(v, -1);
                }
            }

            return isArticulation;
        }

        void articulationDfs(int from, int parent) {
            used[from] = true;
            parents[from] = parent;

            ++time;
            up[from] = tin[from] = time;

            int childrenCount = 0;

            for (Edge e : graph[from]) {
                int to = e.to;

                if (to == parent) continue;

                if (used[to]) {
                    up[from] = min(up[from], tin[to]);
                } else {
                    ++childrenCount;

                    articulationDfs(to, from);
                    up[from] = min(up[from], up[to]);
                    if (up[to] >= tin[from] && parent != -1) {
                        isArticulation[from] = true;
                    }
                }
            }

            if (parent == -1 && childrenCount > 1) {
                isArticulation[from] = true;
            }
        }

        int[] edgeColors;
        int maxEdgeColor;

        int[] paintEdges() {
            this.edgeColors = new int[m];
            Arrays.fill(edgeColors, -1);

            this.maxEdgeColor = -1;

            this.used = new boolean[n];

            for (int v = 0; v < n; ++v) {
                if (!used[v]) {
                    ++maxEdgeColor;
                    paintDfs(v, maxEdgeColor, -1);
                }
            }

            return edgeColors;
        }

        void paintEdge(int edgeIndex, int color) {
            if (edgeColors[edgeIndex] != -1) return;

            edgeColors[edgeIndex] = edgeColors[edgeIndex ^ 1] = color;
        }

        void paintDfs(int from, int color, int parent) {
            used[from] = true;

            for (Edge e : graph[from]) {
                int to = e.to;
                if (to == parent) continue;

                if (!used[to]) {
                    if (up[to] >= tin[from]) {
                        int newColor = ++maxEdgeColor;
                        paintEdge(e.index, newColor);
                        paintDfs(to, newColor, from);
                    } else {
                        paintEdge(e.index, color);
                        paintDfs(to, color, from);
                    }
                } else if (up[to] <= tin[from]){
                    paintEdge(e.index, color);
                }
            }
        }

        Set<Integer>[] collectVertexEdgeColors() {
            Set<Integer>[] vertexEdgeColors = new Set[n];
            for (int v = 0; v < n; ++v) {
                vertexEdgeColors[v] = new HashSet<Integer>();
                for (Edge e : graph[v]) {
                    vertexEdgeColors[v].add(edgeColors[e.index]);
                }
            }

            return vertexEdgeColors;
        }

        VertexBiconnectedGraph build() {
            findArticulationPoints();
            paintEdges();
            createComponentsGraph();

            return this;
        }

        int[][] componentsGraph;

        void createComponentsGraph() {
            Set<Integer>[] vertexEdgeColors = collectVertexEdgeColors();

            int edgeColorShift = vertexEdgeColors.length;
            int size = vertexEdgeColors.length + maxEdgeColor + 1;

            GraphBuilder graphBuilder = GraphBuilder.createInstance(size);
            for (int v = 0; v < vertexEdgeColors.length; ++v) {
                for (int edgeColor : vertexEdgeColors[v]) {
                    graphBuilder.addEdge(v, edgeColor + edgeColorShift);
                }
            }

            this.componentsGraph = graphBuilder.build();
        }

        int[][] toGraph() {
            return componentsGraph;
        }
    }

    /////////////////////////////////////////////////////////////////////

    private static class DSU {

        int[] sizes;

        int[] ranks;
        int[] parents;

        static DSU createInstance(int size) {
            int[] sizes = new int[size];
            Arrays.fill(sizes, 1);

            return new DSU(sizes);
        }

        DSU(int[] sizes) {
            this.sizes = sizes;

            int size = sizes.length;

            this.ranks = new int[size];
            Arrays.fill(ranks, 1);

            this.parents = castInt(order(size));
        }

        int get(int v) {
            if (v == parents[v]) return v;
            return parents[v] = get(parents[v]);
        }

        boolean union(int a, int b) {
            a = get(a);
            b = get(b);

            if (a == b) return false;

            if (ranks[a] < ranks[b]) {
                int tmp = a;
                a = b;
                b = tmp;
            }

            parents[b] = a;
            sizes[a] += sizes[b];

            if (ranks[a] == ranks[b]) ++ranks[a];

            return true;
        }
    }

    /////////////////////////////////////////////////////////////////////
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;

public class A241 {

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();

        int min = n*m;
        int need = 0;
        if(min>k){
            need = min-k;
        }else{
            System.out.println("0");
            System.exit(0);
        }
        if(need<n){
            if(d*need<c){
                System.out.println(d*need);
            }else{
                System.out.println(c);

            }
            System.exit(0);
        }
        int ans=0;
       // System.out.println("need = "+need);
        if(n*d<=c){
            //System.out.println("^^^^");
           // System.out.println(n*d);
            ans=need*d;
            //System.out.println("ans "+ans);
        }else {
            ans+=(need/n)*c;
            int rem = need%n;
            if(rem*d<c){
                ans+=rem*d;
            }else{
                ans+=c;
            }
        }

        System.out.println(ans);

    }

    public static void main(String[] args) throws IOException {
        new A241().solve();

    }
}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt();
		int d = sc.nextInt();
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		int min_que = Integer.MAX_VALUE;
		int total = n * m - k;
		int que_count = 0;
		if (total <= 0) {
			System.out.println(0);
			return;
		}
		for (int i = 0; i <= m; i++) {
			if (total - i * n > 0)
				que_count = i * c + (total - i * n) * d;
			else {
				que_count = i * c;
			}
			min_que = Math.min(que_count, min_que);
		}
		System.out.println(min_que);
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (s.hasNextInt()) {
            int c = s.nextInt();
            int d = s.nextInt();
            int n = s.nextInt();
            int m = s.nextInt();
            int k = s.nextInt();

            int num = 0;
            int numNeed = n * m - k;

            if (numNeed > 0) {
                if (c < d * n) {
                    num += c * (numNeed / n);
                    int numOst = numNeed % n;
                    num += Math.min(numOst * d, c);
                } else {
                    num += numNeed * d;
                }
            } else {
                numNeed = 0;
            }

            System.out.print(num);
        }
        s.close();
    }
}

import java.util.*;
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;

public class A
{
    FastScanner in;
    PrintWriter out;

    public void solve() throws IOException
    {
        int c = in.nextInt();
        int d = in.nextInt();

        int n = in.nextInt();
        int m = in.nextInt();

        int k = in.nextInt();

        int proizv = n * m - k;

        int ret = 0;

        int kolD = d * n;

        while(proizv > 0)
        {
            if(proizv >= n)
            {
                if(kolD > c)
                {
                    proizv -= n;
                    ret += c;
                }
                else
                {
                    proizv -= n;
                    ret += kolD;
                }
            }
            else
            {
                int a = proizv * d;

                if(a > c)
                {
                    proizv -= n;
                    ret += c;
                }
                else
                {
                    proizv -= proizv;
                    ret += a;
                }
            }
        }

        out.println(ret);
    }

    public void run()
    {
        try
        {
            //in  = new FastScanner(new File("kth.in"));
            //out = new PrintWriter(new File("kth.out"));

            in  = new FastScanner();
            out = new PrintWriter(System.out);

            solve();

            out.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    class FastScanner
    {
        BufferedReader  br;
        StringTokenizer st;

        FastScanner()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            }
            catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        String nextLine()
        {
            String ret = null;
            try
        {
                ret = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }

            return ret;
        }

        String next()
        {
            while (st == null || !st.hasMoreTokens())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        int[] nextIntArray(int size)
        {
            int[] array = new int[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextInt();
            }

            return array;
        }

        long[] nextLongArray(int size)
        {
            long[] array = new long[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextLong();
            }

            return array;
        }

        BigInteger nextBigInteger()
        {
            return new BigInteger(next());
        }

        Point nextIntPoint()
        {
            int x = nextInt();
            int y = nextInt();
            return new Point(x, y);
        }

        Point[] nextIntPointArray(int size)
        {
            Point[] array = new Point[size];

            for (int index = 0; index < size; ++index)
            {
                array[index] = nextIntPoint();
            }

            return array;
        }

        List<Integer>[] readGraph(int vertexNumber, int edgeNumber, boolean undirected)
        {
            List<Integer>[] graph = new List[vertexNumber];

            for (int index = 0; index < vertexNumber; ++index)
            {
                graph[index] = new ArrayList<Integer>();
            }

            while (edgeNumber-- > 0)
            {
                int from = nextInt() - 1;
                int to   = nextInt() - 1;

                graph[from].add(to);

                if(undirected)
                    graph[to].add(from);
            }

            return graph;
        }
    }

    public static void main(String[] arg)
    {
        new A().run();
    }
}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
public class icpc
{
    public static void main(String[] args) throws IOException
    {
        Reader in = new Reader();
        //BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        long c = in.nextLong();
        long d = in.nextLong();
        long n = in.nextLong();
        long m = in.nextLong();
        long k = in.nextLong();
        long v = n * m - k;
        long min = Long.MAX_VALUE;
        if (k >= n * m)
        {
            System.out.println(0);
            System.exit(0);
        }
        for (long i=0;i<=v;i++)
        {
            long c1 = i;
            long c2 = Math.max(0, v - (n * c1));
            if (c2 >= 0)
            {
                long ans = c1 * c + c2 * d;
                min = Math.min(min, ans);
            }
        }
        System.out.println(min);
    }
}
class DSU
{
    int[] parent;
    int[] size;
    //Pass number of total nodes as parameter to the constructor
    DSU(int n)
    {
        this.parent = new int[n];
        this.size = new int[n];
        Arrays.fill(parent, -1);
    }

    public void makeSet(int v)
    {
        parent[v] = v;
        size[v] = 1;
    }

    public int findSet(int v)
    {
        if (v == parent[v]) return v;
        return parent[v] = findSet(parent[v]);
    }

    public void unionSets(int a, int b)
    {
        a = findSet(a);
        b = findSet(b);
        if (a != b)
        {
            if (size[a] < size[b])
            {
                int temp = a;
                a = b;
                b = temp;
            }
            parent[b] = a;
            size[a] += size[b];
        }
    }
}
class FastFourierTransform
{
    private void fft(double[] a, double[] b, boolean invert)
    {
        int count = a.length;
        for (int i = 1, j = 0; i < count; i++)
        {
            int bit = count >> 1;
            for (; j >= bit; bit >>= 1)
                j -= bit;
            j += bit;
            if (i < j)
            {
                double temp = a[i];
                a[i] = a[j];
                a[j] = temp;
                temp = b[i];
                b[i] = b[j];
                b[j] = temp;
            }
        }
        for (int len = 2; len <= count; len <<= 1)
        {
            int halfLen = len >> 1;
            double angle = 2 * Math.PI / len;
            if (invert)
                angle = -angle;
            double wLenA = Math.cos(angle);
            double wLenB = Math.sin(angle);
            for (int i = 0; i < count; i += len)
            {
                double wA = 1;
                double wB = 0;
                for (int j = 0; j < halfLen; j++)
                {
                    double uA = a[i + j];
                    double uB = b[i + j];
                    double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
                    double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
                    a[i + j] = uA + vA;
                    b[i + j] = uB + vB;
                    a[i + j + halfLen] = uA - vA;
                    b[i + j + halfLen] = uB - vB;
                    double nextWA = wA * wLenA - wB * wLenB;
                    wB = wA * wLenB + wB * wLenA;
                    wA = nextWA;
                }
            }
        }
        if (invert)
        {
            for (int i = 0; i < count; i++)
            {
                a[i] /= count;
                b[i] /= count;
            }
        }
    }

    public long[] multiply(long[] a, long[] b)
    {
        int resultSize = Integer.highestOneBit(Math.max(a.length, b.length) - 1) << 2;
        resultSize = Math.max(resultSize, 1);
        double[] aReal = new double[resultSize];
        double[] aImaginary = new double[resultSize];
        double[] bReal = new double[resultSize];
        double[] bImaginary = new double[resultSize];
        for (int i = 0; i < a.length; i++)
            aReal[i] = a[i];
        for (int i = 0; i < b.length; i++)
            bReal[i] = b[i];
        fft(aReal, aImaginary, false);
        fft(bReal, bImaginary, false);
        for (int i = 0; i < resultSize; i++)
        {
            double real = aReal[i] * bReal[i] - aImaginary[i] * bImaginary[i];
            aImaginary[i] = aImaginary[i] * bReal[i] + bImaginary[i] * aReal[i];
            aReal[i] = real;
        }
        fft(aReal, aImaginary, true);
        long[] result = new long[resultSize];
        for (int i = 0; i < resultSize; i++)
            result[i] = Math.round(aReal[i]);
        return result;
    }
}
class NumberTheory
{
    public boolean isPrime(long n)
    {
        if(n < 2)
            return false;
        for(long x = 2;x * x <= n;x++)
        {
            if(n % x == 0)
                return false;
        }
        return true;
    }
    public ArrayList<Long> primeFactorisation(long n)
    {
        ArrayList<Long> f = new ArrayList<>();
        for(long x=2;x * x <= n;x++)
        {
            while(n % x == 0)
            {
                f.add(x);
                n /= x;
            }
        }
        if(n > 1)
            f.add(n);
        return f;
    }
    public int[] sieveOfEratosthenes(int n)
    {
        //Returns an array with the smallest prime factor for each number and primes marked as 0
        int[] sieve = new int[n + 1];
        for(int x=2;x * x <= n;x++)
        {
            if(sieve[x] != 0)
                continue;
            for(int u=x*x;u<=n;u+=x)
            {
                if(sieve[u] == 0)
                {
                    sieve[u] = x;
                }
            }
        }
        return sieve;
    }
    public long gcd(long a, long b)
    {
        if(b == 0)
            return a;
        return gcd(b, a % b);
    }
    public long phi(long n)
    {
        double result = n;

        for(long p=2;p*p<=n;p++)
        {
            if(n % p == 0)
            {
                while (n % p == 0)
                    n /= p;
                result *= (1.0 - (1.0 / (double)p));
            }
        }
        if(n > 1)
            result *= (1.0 - (1.0 / (double)n));
        return (long)result;
    }
    public Name extendedEuclid(long a, long b)
    {
        if(b == 0)
            return new Name(a, 1, 0);
        Name n1 = extendedEuclid(b, a % b);
        Name n2 = new Name(n1.d, n1.y, n1.x - (long)Math.floor((double)a / b) * n1.y);
        return n2;
    }
    public long modularExponentiation(long a, long b, long n)
    {
        long d = 1L;
        String bString = Long.toBinaryString(b);
        for(int i=0;i<bString.length();i++)
        {
            d = (d * d) % n;
            if(bString.charAt(i) == '1')
                d = (d * a) % n;
        }
        return d;
    }
}
class Name
{
    long d;
    long x;
    long y;

    public Name(long d, long x, long y)
    {
        this.d = d;
        this.x = x;
        this.y = y;
    }
}
class SuffixArray
{
    int ALPHABET_SZ = 256, N;
    int[] T, lcp, sa, sa2, rank, tmp, c;

    public SuffixArray(String str)
    {
        this(toIntArray(str));
    }

    private static int[] toIntArray(String s)
    {
        int[] text = new int[s.length()];
        for (int i = 0; i < s.length(); i++) text[i] = s.charAt(i);
        return text;
    }

    public SuffixArray(int[] text)
    {
        T = text;
        N = text.length;
        sa = new int[N];
        sa2 = new int[N];
        rank = new int[N];
        c = new int[Math.max(ALPHABET_SZ, N)];
        construct();
        kasai();
    }

    private void construct()
    {
        int i, p, r;
        for (i = 0; i < N; ++i) c[rank[i] = T[i]]++;
        for (i = 1; i < ALPHABET_SZ; ++i) c[i] += c[i - 1];
        for (i = N - 1; i >= 0; --i) sa[--c[T[i]]] = i;
        for (p = 1; p < N; p <<= 1)
        {
            for (r = 0, i = N - p; i < N; ++i) sa2[r++] = i;
            for (i = 0; i < N; ++i) if (sa[i] >= p) sa2[r++] = sa[i] - p;
            Arrays.fill(c, 0, ALPHABET_SZ, 0);
            for (i = 0; i < N; ++i) c[rank[i]]++;
            for (i = 1; i < ALPHABET_SZ; ++i) c[i] += c[i - 1];
            for (i = N - 1; i >= 0; --i) sa[--c[rank[sa2[i]]]] = sa2[i];
            for (sa2[sa[0]] = r = 0, i = 1; i < N; ++i)
            {
                if (!(rank[sa[i - 1]] == rank[sa[i]]
                        && sa[i - 1] + p < N
                        && sa[i] + p < N
                        && rank[sa[i - 1] + p] == rank[sa[i] + p])) r++;
                sa2[sa[i]] = r;
            }
            tmp = rank;
            rank = sa2;
            sa2 = tmp;
            if (r == N - 1) break;
            ALPHABET_SZ = r + 1;
        }
    }

    private void kasai()
    {
        lcp = new int[N];
        int[] inv = new int[N];
        for (int i = 0; i < N; i++) inv[sa[i]] = i;
        for (int i = 0, len = 0; i < N; i++)
        {
            if (inv[i] > 0)
            {
                int k = sa[inv[i] - 1];
                while ((i + len < N) && (k + len < N) && T[i + len] == T[k + len]) len++;
                lcp[inv[i] - 1] = len;
                if (len > 0) len--;
            }
        }
    }
}
class ZAlgorithm
{
    public int[] calculateZ(char input[])
    {
        int Z[] = new int[input.length];
        int left = 0;
        int right = 0;
        for(int k = 1; k < input.length; k++) {
            if(k > right) {
                left = right = k;
                while(right < input.length && input[right] == input[right - left]) {
                    right++;
                }
                Z[k] = right - left;
                right--;
            } else {
                //we are operating inside box
                int k1 = k - left;
                //if value does not stretches till right bound then just copy it.
                if(Z[k1] < right - k + 1) {
                    Z[k] = Z[k1];
                } else { //otherwise try to see if there are more matches.
                    left = k;
                    while(right < input.length && input[right] == input[right - left]) {
                        right++;
                    }
                    Z[k] = right - left;
                    right--;
                }
            }
        }
        return Z;
    }
    public ArrayList<Integer> matchPattern(char text[], char pattern[])
    {
        char newString[] = new char[text.length + pattern.length + 1];
        int i = 0;
        for(char ch : pattern) {
            newString[i] = ch;
            i++;
        }
        newString[i] = '$';
        i++;
        for(char ch : text) {
            newString[i] = ch;
            i++;
        }
        ArrayList<Integer> result = new ArrayList<>();
        int Z[] = calculateZ(newString);

        for(i = 0; i < Z.length ; i++) {
            if(Z[i] == pattern.length) {
                result.add(i - pattern.length - 1);
            }
        }
        return result;
    }
}
class KMPAlgorithm
{
    public int[] computeTemporalArray(char[] pattern)
    {
        int[] lps = new int[pattern.length];

        int index = 0;
        for(int i=1;i<pattern.length;)
        {
            if(pattern[i] == pattern[index])
            {
                lps[i] = index + 1;
                index++;
                i++;
            }
            else
            {
                if(index != 0)
                {
                    index = lps[index - 1];
                }
                else
                {
                    lps[i] = 0;
                    i++;
                }
            }
        }
        return lps;
    }

    public ArrayList<Integer> KMPMatcher(char[] text, char[] pattern)
    {
        int[] lps = computeTemporalArray(pattern);

        int j = 0;
        int i = 0;
        int n = text.length;
        int m = pattern.length;
        ArrayList<Integer> indices = new ArrayList<>();
        while(i < n)
        {
            if(pattern[j] == text[i])
            {
                i++;
                j++;
            }
            if(j == m)
            {
                indices.add(i - j);
                j = lps[j - 1];
            }
            else if(i < n && pattern[j] != text[i])
            {
                if(j != 0)
                    j = lps[j - 1];
                else
                    i = i + 1;
            }
        }
        return indices;
    }
}
class Hashing
{
    public long[] computePowers(long p, int n, long m)
    {
        long[] powers = new long[n];
        powers[0] = 1;
        for(int i=1;i<n;i++)
        {
            powers[i] = (powers[i - 1] * p) % m;
        }
        return powers;
    }
    public long computeHash(String s)
    {
        long p = 31;
        long m = 1_000_000_009;
        long hashValue = 0L;
        long[] powers = computePowers(p, s.length(), m);
        for(int i=0;i<s.length();i++)
        {
            char ch = s.charAt(i);
            hashValue = (hashValue + (ch - 'a' + 1) * powers[i]) % m;
        }
        return hashValue;
    }
}
class BasicFunctions
{
    public long min(long[] A)
    {
        long min = Long.MAX_VALUE;
        for(int i=0;i<A.length;i++)
        {
            min = Math.min(min, A[i]);
        }
        return min;
    }
    public long max(long[] A)
    {
        long max = Long.MAX_VALUE;
        for(int i=0;i<A.length;i++)
        {
            max = Math.max(max, A[i]);
        }
        return max;
    }
}
class MergeSortInt
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]
    void merge(int arr[], int l, int m, int r) {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int[n1];
        int R[] = new int[n2];

        /*Copy data to temp arrays*/
        for (int i = 0; i < n1; ++i)
            L[i] = arr[l + i];
        for (int j = 0; j < n2; ++j)
            R[j] = arr[m + 1 + j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(int arr[], int l, int r) {
        if (l < r) {
            // Find the middle point
            int m = (l + r) / 2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr, m + 1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

}
class MergeSortLong
{
    // Merges two subarrays of arr[].
    // First subarray is arr[l..m]
    // Second subarray is arr[m+1..r]
    void merge(long arr[], int l, int m, int r) {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        long L[] = new long[n1];
        long R[] = new long[n2];

        /*Copy data to temp arrays*/
        for (int i = 0; i < n1; ++i)
            L[i] = arr[l + i];
        for (int j = 0; j < n2; ++j)
            R[j] = arr[m + 1 + j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    void sort(long arr[], int l, int r) {
        if (l < r) {
            // Find the middle point
            int m = (l + r) / 2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr, m + 1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }
}
class Node
{

    int x;
    int y;

    public Node(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object ob)
    {
        if(ob == null)
            return false;
        if(!(ob instanceof Node))
            return false;
        if(ob == this)
            return true;
        Node obj = (Node)ob;
        if(this.x == obj.x && this.y == obj.y)
            return true;
        return false;
    }

    @Override
    public int hashCode()
    {
        return (int)this.x;
    }
}
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')
                break;
            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();
    }
}
class FenwickTree
{
    public void update(long[] fenwickTree,long delta,int index)
    {
        index += 1;
        while(index < fenwickTree.length)
        {
            fenwickTree[index] += delta;
            index = index + (index & (-index));
        }
    }
    public long prefixSum(long[] fenwickTree,int index)
    {
        long sum = 0L;
        index += 1;
        while(index > 0)
        {
            sum += fenwickTree[index];
            index -= (index & (-index));
        }
        return sum;
    }
}
class SegmentTree
{
    public int nextPowerOfTwo(int num)
    {
        if(num == 0)
            return 1;
        if(num > 0 && (num & (num - 1)) == 0)
            return num;
        while((num &(num - 1)) > 0)
        {
            num = num & (num - 1);
        }
        return num << 1;
    }
    public int[] createSegmentTree(int[] input)
    {
        int np2 = nextPowerOfTwo(input.length);
        int[] segmentTree = new int[np2 * 2 - 1];

        for(int i=0;i<segmentTree.length;i++)
            segmentTree[i] = Integer.MIN_VALUE;

        constructSegmentTree(segmentTree,input,0,input.length-1,0);
        return segmentTree;

    }
    private void constructSegmentTree(int[] segmentTree,int[] input,int low,int high,int pos)
    {
        if(low == high)
        {
            segmentTree[pos] = input[low];
            return;
        }
        int mid = (low + high)/ 2;
        constructSegmentTree(segmentTree,input,low,mid,2*pos + 1);
        constructSegmentTree(segmentTree,input,mid+1,high,2*pos + 2);
        segmentTree[pos] = Math.max(segmentTree[2*pos + 1],segmentTree[2*pos + 2]);
    }
    public int rangeMinimumQuery(int []segmentTree,int qlow,int qhigh,int len)
    {
        return rangeMinimumQuery(segmentTree,0,len-1,qlow,qhigh,0);
    }
    private int rangeMinimumQuery(int segmentTree[],int low,int high,int qlow,int qhigh,int pos)
    {
        if(qlow <= low && qhigh >= high){
            return segmentTree[pos];
        }
        if(qlow > high || qhigh < low){
            return Integer.MIN_VALUE;
        }
        int mid = (low+high)/2;
        return Math.max(rangeMinimumQuery(segmentTree, low, mid, qlow, qhigh, 2 * pos + 1),
                rangeMinimumQuery(segmentTree, mid + 1, high, qlow, qhigh, 2 * pos + 2));
    }
}
class Trie
{

    private class TrieNode
    {
        Map<Character, TrieNode> children;
        boolean endOfWord;
        public TrieNode()
        {
            children = new HashMap<>();
            endOfWord = false;
        }
    }

    private final TrieNode root;
    public Trie()
    {
        root = new TrieNode();
    }

    public void insert(String word)
    {
        TrieNode current = root;
        for (int i = 0; i < word.length(); i++)
        {
            char ch = word.charAt(i);
            TrieNode node = current.children.get(ch);
            if (node == null)
            {
                node = new TrieNode();
                current.children.put(ch, node);
            }
            current = node;
        }
        current.endOfWord = true;
    }

    public boolean search(String word)
    {
        TrieNode current = root;
        for (int i = 0; i < word.length(); i++)
        {
            char ch = word.charAt(i);
            TrieNode node = current.children.get(ch);
            if (node == null)
            {
                return false;
            }
            current = node;
        }
        return current.endOfWord;
    }

    public void delete(String word)
    {
        delete(root, word, 0);
    }

    private boolean delete(TrieNode current, String word, int index)
    {
        if (index == word.length())
        {
            if (!current.endOfWord)
            {
                return false;
            }
            current.endOfWord = false;
            return current.children.size() == 0;
        }
        char ch = word.charAt(index);
        TrieNode node = current.children.get(ch);
        if (node == null)
        {
            return false;
        }
        boolean shouldDeleteCurrentNode = delete(node, word, index + 1);

        if (shouldDeleteCurrentNode)
        {
            current.children.remove(ch);
            return current.children.size() == 0;
        }
        return false;
    }
}
class SegmentTreeLazy
{
    public int nextPowerOfTwo(int num)
    {
        if(num == 0)
            return 1;
        if(num > 0 && (num & (num - 1)) == 0)
            return num;
        while((num &(num - 1)) > 0)
        {
            num = num & (num - 1);
        }
        return num << 1;
    }

    public int[] createSegmentTree(int input[])
    {
        int nextPowOfTwo = nextPowerOfTwo(input.length);
        int segmentTree[] = new int[nextPowOfTwo*2 -1];

        for(int i=0; i < segmentTree.length; i++){
            segmentTree[i] = Integer.MAX_VALUE;
        }
        constructMinSegmentTree(segmentTree, input, 0, input.length - 1, 0);
        return segmentTree;
    }

    private void constructMinSegmentTree(int segmentTree[], int input[], int low, int high,int pos)
    {
        if(low == high)
        {
            segmentTree[pos] = input[low];
            return;
        }
        int mid = (low + high)/2;
        constructMinSegmentTree(segmentTree, input, low, mid, 2 * pos + 1);
        constructMinSegmentTree(segmentTree, input, mid + 1, high, 2 * pos + 2);
        segmentTree[pos] = Math.min(segmentTree[2*pos+1], segmentTree[2*pos+2]);
    }

    public void updateSegmentTreeRangeLazy(int input[], int segmentTree[], int lazy[], int startRange, int endRange, int delta)
    {
        updateSegmentTreeRangeLazy(segmentTree, lazy, startRange, endRange, delta, 0, input.length - 1, 0);
    }

    private void updateSegmentTreeRangeLazy(int segmentTree[], int lazy[], int startRange, int endRange, int delta, int low, int high, int pos)
    {
        if(low > high)
        {
            return;
        }
        if (lazy[pos] != 0)
        {
            segmentTree[pos] += lazy[pos];
            if (low != high)
            {
                lazy[2 * pos + 1] += lazy[pos];
                lazy[2 * pos + 2] += lazy[pos];
            }
            lazy[pos] = 0;
        }

        if(startRange > high || endRange < low)
        {
            return;
        }

        if(startRange <= low && endRange >= high)
        {
            segmentTree[pos] += delta;
            if(low != high) {
                lazy[2*pos + 1] += delta;
                lazy[2*pos + 2] += delta;
            }
            return;
        }

        int mid = (low + high)/2;
        updateSegmentTreeRangeLazy(segmentTree, lazy, startRange, endRange, delta, low, mid, 2*pos+1);
        updateSegmentTreeRangeLazy(segmentTree, lazy, startRange, endRange, delta, mid+1, high, 2*pos+2);
        segmentTree[pos] = Math.min(segmentTree[2*pos + 1], segmentTree[2*pos + 2]);
    }

    public int rangeMinimumQueryLazy(int segmentTree[], int lazy[], int qlow, int qhigh, int len)
    {
        return rangeMinimumQueryLazy(segmentTree, lazy, qlow, qhigh, 0, len - 1, 0);
    }

    private int rangeMinimumQueryLazy(int segmentTree[], int lazy[], int qlow, int qhigh, int low, int high, int pos)
    {
        if(low > high)
        {
            return Integer.MAX_VALUE;
        }
        if (lazy[pos] != 0)
        {
            segmentTree[pos] += lazy[pos];
            if (low != high)
            {
                lazy[2 * pos + 1] += lazy[pos];
                lazy[2 * pos + 2] += lazy[pos];
            }
            lazy[pos] = 0;
        }

        if(qlow > high || qhigh < low)
        {
            return Integer.MAX_VALUE;
        }

        if(qlow <= low && qhigh >= high)
        {
            return segmentTree[pos];
        }

        int mid = (low+high)/2;
        return Math.min(rangeMinimumQueryLazy(segmentTree, lazy, qlow, qhigh, low, mid, 2 * pos + 1), rangeMinimumQueryLazy(segmentTree, lazy,  qlow, qhigh, mid + 1, high, 2 * pos + 2));
    }
}

/**
 * Created by Karthik on 02-Aug-17.
 */

import java.io.*;
import java.util.Arrays;

public class DPPractice8 {

    static int[] dp;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] str1 = br.readLine().split(" ");
        String[] str2 = br.readLine().split(" ");
        String[] str3 = br.readLine().split(" ");

        int c = Integer.parseInt(str1[0]);
        int d = Integer.parseInt(str1[1]);
        int n = Integer.parseInt(str2[0]);
        int m = Integer.parseInt(str2[1]);
        int k = Integer.parseInt(str3[0]);

        dp = new int[n*m];
        Arrays.fill(dp, -1);

        System.out.println(recurse(c, d, n, m, n*m-k));

    }

    private static int recurse(int c, int d, int n,int m, int number){
        if(number <= 0){
            return 0;
        }

        if(dp[number] != -1){
            return dp[number];
        }

        int opt1 = c + recurse(c, d, n, m, number-n);
        int opt2 = d + recurse(c, d, n, m, number-1);

        dp[number] = Math.min(opt1, opt2);

        return dp[number];
    }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.StringTokenizer;

public class RCC_A {
	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		Locale.setDefault(Locale.US);
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int c = nextInt(), d = nextInt();
		int n = nextInt(), m = nextInt();
		int k = nextInt();
		int uchas = n * m - k;
		int min = 1000000;
		for (int i = 0; i <= m*n; i++) {
			for (int j = 0; j <= m*n; j++) {
				if (i * n + j >= uchas) {
					min = Math.min(min, i * c + j * d);
				}
			}
		}
		pw.println(min);
		pw.close();
	}

	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	private static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}

import java.util.Scanner;

public final class test_A {

    public  static void main(String[] args) {
        Scanner datain = new Scanner(System.in);
        int c = datain.nextInt();
        int d = datain.nextInt();
        int n = datain.nextInt();
        int m = datain.nextInt();
        int k = datain.nextInt();
        int res=d*(n*m-k);

        for(int x1=1;x1<m-k/n+1;x1++){
            int x2=n*m-n*x1-k;
            int res_tmp=(x2>0)?c*x1+d*x2:c*x1;
            if(res>res_tmp){res=res_tmp;}
        }
        if(res<0){res=0;}
        System.out.println(res);
    }

}

import java.io.*;
import java.util.*;
import java.text.*;

public class Main {
	public static void main (String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String st[] = br.readLine().split(" ");
		int c=Integer.parseInt(st[0]);
		int d=Integer.parseInt(st[1]);
		st=br.readLine().split(" ");
		int n=Integer.parseInt(st[0]);
		int m=Integer.parseInt(st[1]);
		st=br.readLine().split(" ");
		int k=Integer.parseInt(st[0]);
		int dp[][]=new int[2][1000000];

		for(int i=1;i<dp[0].length;i++){
			if(i-n>=0&&dp[0][i-n]!=Integer.MAX_VALUE){
				dp[0][i]+=dp[0][i-n]+c;
			}
			else{
				dp[0][i]=Integer.MAX_VALUE;
			}
		}
		int ans=Integer.MAX_VALUE;

		for(int i=0;i<dp[0].length;i++){
			if(i-1>=0)
			dp[1][i]=Math.min(dp[1][i-1]+d,dp[0][i]);
			if(i>=n*m-k)
			ans=Math.min(ans,dp[1][i]);
		}
	/*	for(int i=0;i<20;i++){
			System.out.print(dp[0][i]+" ");
		}
		System.out.println();
		for(int i=0;i<20;i++){
			System.out.print(dp[1][i]+" ");
		}*/
		System.out.println(ans);

    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class T417A {

	public int solve(int c, int d, int n, int m, int k) {
		int res = n * m - k;

		int ans = 0;
		while (res > 0) {
			if (res >= n) {
				ans += Math.min(c, d * n);
				res -= n;
			} else {
				ans += Math.min(c, d * res);
				res = 0;
			}
		}
		return ans;
	}
	public static void main(String[] args) {
		FastScanner in = new FastScanner();
		System.out.println(new T417A().solve(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt()));

	}
	static class FastScanner {

		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

	}
}

import java.io.*;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    PrintWriter out = new PrintWriter(outputStream);
    TaskB solver = new TaskB();
    solver.solve(1, in, out);
    out.close();
  }
}

class TaskB {
  public void solve(int testNumber, InputReader in, PrintWriter out) {
    int c = in.nextInt();
    int d = in.nextInt();
    int n = in.nextInt();
    int m = in.nextInt();
    int k = in.nextInt();
    int need = Math.max(n * m - k, 0);
    int ans = Integer.MAX_VALUE;
    for (int i = 0; i <= 10000; i++) {
      for (int j = 0; j <= 10000; j++) {
        if (i * n + j >= need) {
          ans = Math.min(ans, c * i + d * j);
        }
      }
    }
    out.println(ans);
  }
}

class InputReader {
  private BufferedReader reader;
  private StringTokenizer tokenizer;

  public InputReader(InputStream stream) {
    reader = new BufferedReader(new InputStreamReader(stream));
    tokenizer = null;
  }

  public int nextInt() {
    return Integer.parseInt(next());
  }

  public String next() {
    while (tokenizer == null || !tokenizer.hasMoreTokens()) {
      try {
        tokenizer = new StringTokenizer(reader.readLine());
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    return tokenizer.nextToken();
  }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
//package RCC2014;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

/**
 *
 * @author tino chagua
 */
public class A {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] cad = br.readLine().split(" ");
        int c = Integer.valueOf(cad[0]);
        int d = Integer.valueOf(cad[1]);

        cad = br.readLine().split(" ");
        int n = Integer.valueOf(cad[0]);
        int m = Integer.valueOf(cad[1]);

        int k = Integer.valueOf(br.readLine());

        int min = n * m - k;

        if (min <= 0) {
            System.out.println(0);
            return;
        }

        int[] total = new int[min + 1];

        for (int y = 0; y < min + 1; y++) {
            int aux = min - y;
            int x = (aux / n);
            if (aux % n != 0) {
                x++;
            }
            total[y] = x * c + y * d;
        }
        Arrays.sort(total);
        System.out.println(total[0]);
    }
}

import java.util.*;
public class Elimination {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt(), d = sc.nextInt(), n = sc.nextInt(), m = sc.nextInt(), k = sc.nextInt();
		int min = n*m - k;
		int q = 0;
		if(min <= 0){
			System.out.println(0);
			return;
		}
		while(min >= n){
			q += Math.min(c, n*d);
			min -= n;
		}
		q += Math.min(c, min*d);
		System.out.println(q);
	}

}

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

/**
 * Created with IntelliJ IDEA.
 * User: Aksenov239
 * Date: 12.04.14
 * Time: 23:29
 * To change this template use File | Settings | File Templates.
 */
public class game_va {
    public static void main(String[] args) {
        new game_va().run();
    }

    BufferedReader br;
    StringTokenizer in;
    PrintWriter out;

    public String nextToken() throws IOException {
        while (in == null || !in.hasMoreTokens()) {
            in = new StringTokenizer(br.readLine());
        }

        return in.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public void solve() throws IOException {
        int cb = nextInt();
        int ca = nextInt();
        int na = nextInt();
        int nb = nextInt();
        int k = nextInt();

        nb -= k / na;
        k %= na;

        if (nb <= 0) {
            out.println(0);
            return;
        }
        out.println(Math.min(nb * cb, Math.min((na - k) * ca + (nb - 1) * cb, (na - k) * ca + (nb - 1) * na * ca)));
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            solve();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

}

import java.util.Scanner;
public class Q417A2
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();
        int no_of_problems = 0;
        int no_of_winners = k;
        while(no_of_winners < n*m)
        {
            if(c/n <= d && (n*m-no_of_winners)*d > c)
            {
                no_of_winners += n;
                no_of_problems += c;
            }
            else
            {
                no_of_winners += 1;
                no_of_problems += d;
            }
        }
        System.out.println(no_of_problems);
    }

}

/*Contest 417*/
import java.util.*;

public class c417{
	public static void main(String[] args){
	Scanner input = new Scanner(System.in);
	int c = input.nextInt();
	int d = input.nextInt();
	int n = input.nextInt();
	int m = input.nextInt();
	int k = input.nextInt();

	int min = n*m-k;
	int output = 0;
	while(min>0){
		if(min>=n){
			min -= n;
			output += Math.min(c,n*d);
		}else{
			output += Math.min(c,min*d);
			min = 0;
		}
	}
	System.out.println(output);
	}
}

import java.io.BufferedReader;
import java.io.IOError;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Div2TaskA {

	FastIO scan = new FastIO();
	PrintWriter cout = new PrintWriter(System.out);

	void run() {

		int c = scan.nextInt();
		int d = scan.nextInt();
		int n = scan.nextInt();
		int m = scan.nextInt();
		int k = scan.nextInt();

		int sum = n * m - k;
		int answer = Integer.MAX_VALUE;
		int i = 0;

		for (i = 0; i * n <= sum; i++) {
			answer = Math.min(answer, (sum - i * n) * d + i * c);
		}
		answer = Math.min(answer, i * c);

		System.out.println(answer);

	}

	public static void main(String args[]) {
		new Div2TaskA().run();
	}

	public class FastIO {
		BufferedReader br;
		StringTokenizer st;
		PrintWriter out;

		public FastIO(InputStream in, OutputStream o) {
			br = new BufferedReader(new InputStreamReader(in));
			out = new PrintWriter(new OutputStreamWriter(o));
			eat("");
		}

		public FastIO() {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			eat("");
		}

		public void eat(String s) {
			st = new StringTokenizer(s);
		}

		public String nextLine() {
			try {
				return br.readLine();
			} catch (IOException e) {
				throw new IOError(e);
			}
		}

		public boolean hasNext() {
			while (!st.hasMoreTokens()) {
				String s = nextLine();
				if (s == null)
					return false;
				eat(s);
			}
			return true;
		}

		public String next() {
			hasNext();
			return st.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public void print(String ans) {
			out.print(ans);
			out.flush();
		}

		public void println(String ans) {
			out.println(ans);
			out.flush();
		}

		public void close() {
			out.close();
		}

	}
}

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {
    class Input {
        BufferedReader bf;
        StringTokenizer st;

        Input(InputStream stream) throws IOException {
            bf = new BufferedReader(new InputStreamReader(stream));
            st = new StringTokenizer("");
        }

        int nextInt() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());

            return Integer.parseInt(st.nextToken());
        }

        long nextLong() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Long.parseLong(st.nextToken());
        }

        double nextDouble() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Double.parseDouble(st.nextToken());
        }

        void readLine() throws IOException {
            st = new StringTokenizer(bf.readLine());
        }

        String nextString() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        String nextLine() throws IOException {
            return bf.readLine();
        }

        void close() throws IOException {
            bf.close();
        }
    }

    Input in;

    public class Problem {

        class Point implements Comparable<Point> {
            int x, y, p;

            Point(int a, int b, int k) {
                x = a;
                y = b;
                p = k;
            }

            @Override
            public int compareTo(Point o) {
                return Integer.compare(this.x, o.x);
            }
        }

        @SuppressWarnings("deprecation")
        public void solve() throws IOException {

            int c = in.nextInt();
            int d = in.nextInt();
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            int N = 10001;
            int[] a = new int[N];
            Arrays.fill(a, 0);

            for (int i = 0; i <= n; i++) {
                a[i] = Math.min(c, d * i);
            }

            for(int i = n + 1; i < N; i++) {
                a[i] = Math.min(a[i-1] + d, a[i - n] + c);
            }

            int s = Math.max(n * m - k, 0);

            int res = a[s];

            System.out.println(res);
        }
    }

    public void solveProblem() throws IOException {

        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        in = new Input(oj ? System.in : new FileInputStream("//home/bamboo/GitProjects/studyDir/Acm/input.txt"));

        // in = new Input(System.in);
        // in = new Input(new FileInputStream("D:/Codes/Java/input.txt"));
        new Problem().solve();
        in.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().solveProblem();
    }

}

import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author @thnkndblv
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();

        int n = in.nextInt();
        int m = in.nextInt();

        int k = in.nextInt();

        int target = n * m - k;

        int ans = m * c;

        for (int i = 0; i <= m; i++)
        {
            int mains = c * i;
            int rem = target - i * n;

            int adds = Math.max( 0, rem ) * d;

            ans = Math.min( ans, mains + adds );
        }

        out.println( ans );
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

import java.util.Scanner;

public class A {
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        while(scan.hasNext()){
            int c= scan.nextInt();
            int d = scan.nextInt();
            int n = scan.nextInt();
            int m = scan.nextInt();
            int k = scan.nextInt();
            if(k>=n*m)System.out.println(0);
            else{
                int temp=n*m-k;
                if((double)c/n>d){
                    System.out.println((n*m-k)*d);
                }
                else{
                    int ans=temp/n;
                    int x = ans*c;
                    if(ans*n==temp){
                        System.out.println(x);
                    }
                    else{
                        int t =temp-ans*n;
                        if(t*d<c)x+=t*d;
                        else x+=c;
                        System.out.println(x);
                    }
                }
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class A {
    public static void main(String[] args) throws IOException {
        BufferedReader input =
			new BufferedReader(new InputStreamReader(System.in));
		String[] cd = input.readLine().split(" ");
		String[] nm = input.readLine().split(" ");
		int k = Integer.parseInt(input.readLine());
		int c = Integer.parseInt(cd[0]);
		int d = Integer.parseInt(cd[1]);
		int n = Integer.parseInt(nm[0]);
		int m = Integer.parseInt(nm[1]);
		int s = n*m - k;
		if (s < 0) s = 0;
		int min = Integer.MAX_VALUE;
		for (int i = 0; i <= s/n + 1; i++) {
		    if (min > i * c + Math.max(s - i*n,0) * d)
		        min = i * c + Math.max(s - i*n,0) * d;
		}
		System.out.println(min);
    }
}

import java.util.Scanner;

public class First {

	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt(), d = sc.nextInt(), n = sc.nextInt(), m = sc.nextInt(), k = sc.nextInt();
		int num = 0;
		int numNeed = n*m - k;
		if(numNeed > 0){
		if(c < d*n){
			num+=c*(numNeed/n);
			int numOst = numNeed%n;
			num+=Math.min(numOst*d, c);

		}
		else{
			num+=numNeed*d;
		}}
		else
			numNeed = 0;
		System.out.print(num);
	}
}

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

public class A417 {

  public static void main(String[] args) {

    int c, d, n, m, k;
    int problems = 0;

    Scanner s = new Scanner(System.in);
    c = s.nextInt();
    d = s.nextInt();
    n = s.nextInt();
    m = s.nextInt();
    k = s.nextInt();

    int total = n*m-k;

    if(total < 0)
      System.out.println(0);

    else{
      while(total >0){
        if(n*d < c || (total < n && total*d < c)){
          total--; problems += d;
        }
        else{
          total -= n;
          problems +=c;
        }
      }
      System.out.println(problems);
    }
  }
}

import java.util.*;
public class CodeforcesA417 {
	public static void main(String[] args){
		Scanner br = new Scanner(System.in);
		int c = br.nextInt();
		int d = br.nextInt();
		int n = br.nextInt();
		int m = br.nextInt();
		int k = br.nextInt();

		int need = n*m-k;
		if(need <= 0){
			System.out.println(0);
			return;
		}
		int[] ans = new int[need+1 + 300];
		Arrays.fill(ans, 1000000000);
		ans[0] = 0;
		for(int i = 0;i<need;i++){
			if(ans[i] != -1){
				ans[i+n] = Math.min(ans[i+n], c+ans[i]);
				ans[i+1] = Math.min(ans[i+1], d+ans[i]);
			}
		}
		int min = 10000000;
		for(int i = need;i<need+300;i++){
			if(ans[i] == -1) continue;
			min = Math.min(min, ans[i]);
		}
		System.out.println(min);
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (s.hasNextInt()) {
            int c = s.nextInt();
            int d = s.nextInt();
            int n = s.nextInt();
            int m = s.nextInt();
            int k = s.nextInt();

            int num = 0;
            int numNeed = n * m - k;

            if (numNeed > 0) {
                if (c < d * n) {
                    num += c * (numNeed / n);
                    int numOst = numNeed % n;
                    num += Math.min(numOst * d, c);
                } else {
                    num += numNeed * d;
                }
            } else {
                numNeed = 0;
            }

            System.out.print(num);
        }
        s.close();
    }
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Alex
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, OutputWriter out){
	    int cmainrounds = in.ri(), dadditionalrounds = in.ri(), ntoppeople = in.ri(), mmultiplier = in.ri(), kwinners = in.ri();
	    int needmore = ntoppeople * mmultiplier - kwinners;
	    if (needmore <= 0){
		    out.printLine(0);
		    return;
	    }
	    int res = Integer.MAX_VALUE;
	    for(int mainrounds = 0; mainrounds < 5000; mainrounds++) {
		    int peoplefrommain = ntoppeople * mainrounds;
		    int wantevenmore = Math.max(0, needmore - peoplefrommain);
		    int problems = mainrounds * cmainrounds + dadditionalrounds * wantevenmore;
		    res = Math.min(res, problems);
	    }
	    out.printLine(res);
    }
}

class InputReader {
	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 ri(){
		return readInt();
	}

	public int readInt() {
		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 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;
	}
	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}
	public void close() {
		writer.close();
	}
	public void printLine(int i) {
		writer.println(i);
	}

}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
//package RCC2014;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

/**
 *
 * @author tino chagua
 */
public class A {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] cad = br.readLine().split(" ");
        int c = Integer.valueOf(cad[0]);
        int d = Integer.valueOf(cad[1]);

        cad = br.readLine().split(" ");
        int n = Integer.valueOf(cad[0]);
        int m = Integer.valueOf(cad[1]);

        int k = Integer.valueOf(br.readLine());

        int min = n * m - k;

        if (min <= 0) {
            System.out.println(0);
            return;
        }

        int[] total = new int[min + 1];

        for (int y = 0; y < min + 1; y++) {
            int aux = min - y;
            int x = (aux / n);
            if (aux % n != 0) {
                x++;
            }
            total[y] = x * c + y * d;
        }
        Arrays.sort(total);
        System.out.println(total[0]);
    }
}

import java.util.*;
import java.lang.Math;

public class Main{
    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        int c = myScanner.nextInt();
        int d = myScanner.nextInt();
        int n = myScanner.nextInt();
        int m = myScanner.nextInt();
        int k = myScanner.nextInt();
        int nCon = n * m - k, result = 10000000;
        for(int i = 0; i <= nCon; i++){
            for(int j = 0; j <= nCon; j++){
                int tempCon = i * n + j;
                if( tempCon >= nCon){
                    result = Math.min(result, i * c + d * j);
                }
            }
        }
        System.out.println(nCon > 0 ? result : 0);
    }

}

import java.io.*;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;

public class CodeForces {

	public void solve() throws IOException {
		int c = nextInt();
		int d = nextInt();
		int n = nextInt();
		int m = nextInt();
		int k = nextInt();

		int res = Integer.MAX_VALUE;
		int nm = n * m - k;

		if(nm<=0) {
			System.out.println(0);
		} else {
		for (int i = 0; i <= nm / n + 1; i++) {
			for (int j = 0; j <= nm + 1; j++) {
				if(i*n+j>=nm){
					res = Math.min(res, i*c+j*d);
				}
			}
		}

		System.out.println(res);
		}
	}

	public static void main(String[] args) {
		new CodeForces().run();
	}

	int NOD(int a, int b) {
		while (a != 0 && b != 0) {
			if (a >= b)
				a = a % b;
			else
				b = b % a;
		}
		return a + b;
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	boolean isOuterFile = false;

	public void run() {
		try {
			if (isOuterFile) {
				reader = new BufferedReader(new FileReader(
						"C:\\work\\javaprojects\\CodeForces\\SCC.txt"));
				// out = new PrintWriter(new BufferedWriter(new FileWriter(
				// "output.txt")));
				// out = new PrintWriter(System.out);
			} else {
				reader = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			tokenizer = null;

			// long time = System.currentTimeMillis();
			solve();
			// out.println(System.currentTimeMillis() - time);
			reader.close();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}

import java.util.*;
import java.lang.*;
import java.io.*;
public class P1
{
	public static void main (String[] args) throws java.lang.Exception
	{
	Scanner sc = new Scanner(System.in);
        int cb = sc.nextInt();
        int ca = sc.nextInt();
        int na = sc.nextInt();
        int nb = sc.nextInt();
        int k =  sc.nextInt();

        nb -= k / na;
        k %= na;

        if (nb <= 0)
        {
            System.out.println(0);
            System.exit(0);
        }
        System.out.println(Math.min(nb * cb, Math.min((na - k) * ca + (nb - 1) * cb, (na - k) * ca + (nb - 1) * na * ca)));
    }

}

/**
 * @author panicker
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class ProblemB {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }
}

class Task {

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt(), d = in.nextInt(), n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
        int minPersons = n * m - k;
        if (minPersons <= 0) {
            out.print(0);
        } else {
            int dp[] = new int[minPersons + 1];

            dp[1] = Math.min(c, d);
            for (int i = 2; i <= minPersons; i++) {
                dp[i] = 50000;
                for (int j = 1; j < i; ++j) {
                    if (i - n <= 0)
                        dp[i] = Math.min(Math.min(dp[j] + dp[i - j], dp[i - 1] + d), c);
                    else {
                        dp[i] = Math.min(Math.min(dp[j] + dp[i - j], dp[i - 1] + d), dp[i]);
                    }
                }
            }
            out.print(dp[minPersons]);
        }
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

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

public class A {
    public static void solution(BufferedReader reader, PrintWriter out)
            throws IOException {
        In in = new In(reader);
        int c = in.nextInt(), d = in.nextInt();
        int n = in.nextInt(), m = in.nextInt();
        int k = in.nextInt();
        int min = Integer.MAX_VALUE;
        int p = n * m - k;
        for (int i = 0; i <= m; i++) {
            int j = Math.max(p - n * i, 0);
            int total = i * c + j * d;
            min = Math.min(min, total);
        }
        out.println(min);
    }

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(
                new BufferedWriter(new OutputStreamWriter(System.out)));
        solution(reader, out);
        out.close();
    }

    protected static class In {
        private BufferedReader reader;
        private StringTokenizer tokenizer = new StringTokenizer("");

        public In(BufferedReader reader) {
            this.reader = reader;
        }

        public String next() throws IOException {
            while (!tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }
    }
}

import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class Main {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Main().run();
        // Sworn to fight and die
    }

    public static void mergeSort(int[] a) {
        mergeSort(a, 0, a.length - 1);
    }

    private static void mergeSort(int[] a, int levtIndex, int rightIndex) {
        final int MAGIC_VALUE = 50;
        if (levtIndex < rightIndex) {
            if (rightIndex - levtIndex <= MAGIC_VALUE) {
                insertionSort(a, levtIndex, rightIndex);
            } else {
                int middleIndex = (levtIndex + rightIndex) / 2;
                mergeSort(a, levtIndex, middleIndex);
                mergeSort(a, middleIndex + 1, rightIndex);
                merge(a, levtIndex, middleIndex, rightIndex);
            }
        }
    }

    private static void merge(int[] a, int levtIndex, int middleIndex,
            int rightIndex) {
        int length1 = middleIndex - levtIndex + 1;
        int length2 = rightIndex - middleIndex;
        int[] levtArray = new int[length1];
        int[] rightArray = new int[length2];
        System.arraycopy(a, levtIndex, levtArray, 0, length1);
        System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
        for (int k = levtIndex, i = 0, j = 0; k <= rightIndex; k++) {
            if (i == length1) {
                a[k] = rightArray[j++];
            } else if (j == length2) {
                a[k] = levtArray[i++];
            } else {
                a[k] = levtArray[i] <= rightArray[j] ? levtArray[i++]
                        : rightArray[j++];
            }
        }
    }

    private static void insertionSort(int[] a, int levtIndex, int rightIndex) {
        for (int i = levtIndex + 1; i <= rightIndex; i++) {
            int current = a[i];
            int j = i - 1;
            while (j >= levtIndex && a[j] > current) {
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = current;
        }
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    class LOL implements Comparable<LOL> {
        int x;
        int y;
        int num;

        public LOL(int x, int y, int num) {
            this.x = x;
            this.y = y;
            this.num = num;
        }

        @Override
        public int compareTo(LOL o) {

            if (y == o.y)
                return x - o.x;
            return o.y - y; // ---->
            // return o.x - x; // <----
        }

    }

    public void solve() throws IOException {

        int c = readInt();
        int d = readInt();
        int n = readInt();
        int m = readInt();
        int k = readInt();

//      int all = n*m-k;
//
//      int ans = 0;
//
//      int nd = d*n;
//      int nc = c*n;
//
//
//      int cur = Math.min(nd,nc);
//
//      int q = 0;
//
//      if (all % cur !=0) q++;
//
//      int mod = all % cur;
//
//      int x = cur - Math.min(d,c)
//      ans = Math.min(all / cur + q,all/x+d*mod);
//
   //   out.print(ans);

        int ans = Integer.MAX_VALUE;
        for (int i = 0; i <= 1000; i++){
            for (int j = 0; j <=10000; j++){
                if ( n*i+j>=n*m-k)
                    ans = Math.min(ans, c*i+d*j);
            }
        }
        out.print(ans);

    }

}

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;

/*
  br = new BufferedReader(new FileReader("input.txt"));
  pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
  br = new BufferedReader(new InputStreamReader(System.in));
  pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
	private static BufferedReader br;
	private static StringTokenizer st;
	private static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		//int qq = 1;
		int qq = Integer.MAX_VALUE;
		//int qq = readInt();
		for(int casenum = 1; casenum <= qq; casenum++) {
			int main = readInt();
			int add = readInt();
			int n = readInt();
			int m = readInt();
			int k = readInt();
			int[] dp = new int[n*m+1];
			Arrays.fill(dp, 1 << 30);
			dp[0] = 0;
			for(int i = 0; i < dp.length; i++) {
				if(i+1 < dp.length) {
					dp[i+1] = Math.min(dp[i+1], dp[i] + add);
				}
				if(i+n < dp.length) {
					dp[i+n] = Math.min(dp[i+n], dp[i] + main);
				}
			}
			int index = Math.max(n*m-k, 0);
			int ret = Integer.MAX_VALUE;
			for(int a = index; a < dp.length; a++) {
				ret = Math.min(ret, dp[a]);
			}
			pw.println(ret);
		}
		exitImmediately();
	}

	private static void exitImmediately() {
		pw.close();
		System.exit(0);
	}

	private static long readLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	private static double readDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	private static int readInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	private static String nextLine() throws IOException  {
		if(!br.ready()) {
			exitImmediately();
		}
		st = null;
		return br.readLine();
	}

	private static String nextToken() throws IOException  {
		while(st == null || !st.hasMoreTokens())  {
			if(!br.ready()) {
				exitImmediately();
			}
			st = new StringTokenizer(br.readLine().trim());
		}
		return st.nextToken();
	}
}

import java.util.Scanner;

public class mergelink {
    public static void main(String[] args) {
        Scanner s=new Scanner (System.in);
        int n,m,c,d,k;
        c=s.nextInt();
        d=s.nextInt();
        n=s.nextInt();
        m=s.nextInt();
        k=s.nextInt();
        if(k>=n*m)
            {System.out.print("0");}

        else
        {
            int sp=(n*m-k)>=0?n*m-k+1:0;
        int [] a=new int [sp];
        a[0]=0;

        for(int i=1;i<=n*m-k;i++)
            a[i]=Math.min(i-n>0?a[i-n]+c:c,a[i-1]+d);

        System.out.print(a[n*m-k]);

        }
    }
        }

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author PrateekNischal
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Elimination solver = new Elimination();
		solver.solve(1, in, out);
		out.close();
	}
}

class Elimination {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int lim = Math.max(0 ,n*m - k);
        int res = 0;
        while (lim >= n)
        {
            if (c <= n*d) {
                lim -= n;
                res += c;
            }
            else{
                lim -= n;
                res += n*d;
            }
        }
        res += Math.min(c, lim*d);
        out.println(res);
    }
}

class InputReader
{
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    public int bufferSize = 32768;
    public InputReader(InputStream stream)
    {
        reader = new BufferedReader(new InputStreamReader(stream), bufferSize);
        tokenizer = null;
    }

    public String next()
    {
        while (tokenizer == null || !tokenizer.hasMoreTokens()){
            try{
                tokenizer = new StringTokenizer(reader.readLine());
            }catch(IOException e){throw new RuntimeException(e);}
        }
        return tokenizer.nextToken();
    }

    public int nextInt(){
        return Integer.parseInt(next());
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class A {
    public static void main(String[] args) throws IOException {
        BufferedReader input =
			new BufferedReader(new InputStreamReader(System.in));
		String[] cd = input.readLine().split(" ");
		String[] nm = input.readLine().split(" ");
		int k = Integer.parseInt(input.readLine());
		int c = Integer.parseInt(cd[0]);
		int d = Integer.parseInt(cd[1]);
		int n = Integer.parseInt(nm[0]);
		int m = Integer.parseInt(nm[1]);
		int s = n*m - k;
		if (s < 0) s = 0;
		int min = Integer.MAX_VALUE;
		for (int i = 0; i <= s/n + 1; i++) {
		    if (min > i * c + Math.max(s - i*n,0) * d)
		        min = i * c + Math.max(s - i*n,0) * d;
		}
		System.out.println(min);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;

public class A241 {

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();

        int min = n*m;
        int need = 0;
        if(min>k){
            need = min-k;
        }else{
            System.out.println("0");
            System.exit(0);
        }
        if(need<n){
            if(d*need<c){
                System.out.println(d*need);
            }else{
                System.out.println(c);

            }
            System.exit(0);
        }
        int ans=0;
       // System.out.println("need = "+need);
        if(n*d<=c){
            //System.out.println("^^^^");
           // System.out.println(n*d);
            ans=need*d;
            //System.out.println("ans "+ans);
        }else {
            ans+=(need/n)*c;
            int rem = need%n;
            if(rem*d<c){
                ans+=rem*d;
            }else{
                ans+=c;
            }
        }

        System.out.println(ans);

    }

    public static void main(String[] args) throws IOException {
        new A241().solve();

    }
}

import java.util.Scanner;

public class TaskA {

    public static void main(String[] args) {
        new A().run();
    }

}

class A {

    Scanner in = new Scanner(System.in);
//  PrintWriter put = new PrintWriter(System.out);

    public void run() {
        int c = in.nextInt(), d = in.nextInt();
        int n = in.nextInt(), m = in.nextInt();
        int k = in.nextInt();
        if (k >= n*m) {
            System.out.println("0");
            return ;
        }
        if (c > d*n) {
            System.out.println(d*(m*n-k));
            return;
        }
        int tt = (m*n-k)%n;
        System.out.println((m*n-k)/n*c+Math.min(c, d*tt));
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (s.hasNextInt()) {
            int c = s.nextInt();
            int d = s.nextInt();
            int n = s.nextInt();
            int m = s.nextInt();
            int k = s.nextInt();

            int num = 0;
            int numNeed = n * m - k;

            if (numNeed > 0) {
                if (c < d * n) {
                    num += c * (numNeed / n);
                    int numOst = numNeed % n;
                    num += Math.min(numOst * d, c);
                } else {
                    num += numNeed * d;
                }
            } else {
                numNeed = 0;
            }

            System.out.print(num);
        }
        s.close();
    }
}

/*Contest 417*/
import java.util.*;

public class c417{
	public static void main(String[] args){
	Scanner input = new Scanner(System.in);
	int c = input.nextInt();
	int d = input.nextInt();
	int n = input.nextInt();
	int m = input.nextInt();
	int k = input.nextInt();

	int min = n*m-k;
	int output = 0;
	while(min>0){
		if(min>=n){
			min -= n;
			output += Math.min(c,n*d);
		}else{
			output += Math.min(c,min*d);
			min = 0;
		}
	}
	System.out.println(output);
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.PriorityBlockingQueue;

import javax.swing.ComboBoxEditor;

public class aa {
	public static class node {
		int d;
		int t;

		node(int d, int t) {
			this.d = d;
			this.t = t;
		}
	}

	public static void solve() {

	}

	public static void main(String[] args) throws IOException {

		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder();
		String y[] = in.readLine().split(" ");
		int f = Integer.parseInt(y[0]);
		int s = Integer.parseInt(y[1]);
		y = in.readLine().split(" ");
		int num1 = Integer.parseInt(y[0]);
		int num2 = Integer.parseInt(y[1]);
		int k = Integer.parseInt(in.readLine());
		int ans = k;
		int limit = num1 * num2;
		int e = limit - ans;
		int count1 = s * e;
		int count2 = (e / num1) * f;
		if (e % num1 != 0) {
			int t1 = s * (e % num1);
			int t2 = f;
			count2 += Math.min(t1, t2);
		}
		int count=Math.max(0, Math.max(count1, count2));
		System.out.println(count);
		out.close();

	}
}

import java.util.*;
import static java.lang.Math.*;

public class Elimination
{
    public static void main(String []av) {
        Scanner s = new Scanner(System.in);
        int c = s.nextInt();    // <=100
        int d = s.nextInt();    // <=100
        int n = s.nextInt();    // <=100
        int m = s.nextInt();    // <=100
        int k = s.nextInt();    // <=100
        int need = n * m - k;   // <= 10000

        // c * x * n + d * y >= need
        // (c * x + d * y) -> min
        int _min = Integer.MAX_VALUE;
        for (int y = 0; y < 10001; y++) {
            // c * n * x >= need - d * y
            int dx = max(need - d * y, 0);
            while (dx % (c * n) != 0)
                dx++;

            int x = dx / (c * n);
            _min = min(_min, c * x + d * y);
        }
        System.out.println(_min);
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;

public class Main{
	static int c , d  , n , m;
	static int memo[];
	public static int search(int remP)
	{
		if(remP<=0)
			return 0;
		if(memo[remP]!=-1)
			return memo[remP];
		return memo[remP]=Math.min(1+search(remP-d), c+search(remP-n));
	}
	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		c = sc.nextInt() ; d = sc.nextInt();
		n = sc.nextInt() ; m = sc.nextInt();
		int k = sc.nextInt();
		memo = new int[1001];
		Arrays.fill(memo, -1);
		System.out.println(search(n*m-k));
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;

public class A241 {

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();

        int min = n*m;
        int need = 0;
        if(min>k){
            need = min-k;
        }else{
            System.out.println("0");
            System.exit(0);
        }
        if(need<n){
            if(d*need<c){
                System.out.println(d*need);
            }else{
                System.out.println(c);

            }
            System.exit(0);
        }
        int ans=0;
       // System.out.println("need = "+need);
        if(n*d<=c){
            //System.out.println("^^^^");
           // System.out.println(n*d);
            ans=d;
            //System.out.println("ans "+ans);
        }else {
            ans+=(need/n)*c;
            int rem = need%n;
            if(rem*d<c){
                ans+=rem*d;
            }else{
                ans+=c;
            }
        }

        System.out.println(ans);

    }

    public static void main(String[] args) throws IOException {
        new A241().solve();

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.*;

public class Round260 {

    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(in, out);
        out.close();
    }
}

/*
 * Am I wrong for thinking out the box from where I stay? Am I wrong for saying
 * that I choose another way?
 *
 * I ain't trying to do what everybody else doing Just cause everybody doing
 * what they all do
 *
 * If one thing I know, I'll fall but I'll grow
 *
 * I'm walking down this road of mine, this road that I call home
 *
 * So am I wrong?
 */

class TaskC {

    public void solve(InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();

        long res = 0;

        long remain = n * m - k;
        if (remain <= 0) {
            out.println(0);
            return;
        }

        int main = n/c;
        if (main >= 1) {
            res = (remain / n) * c;
            remain -= (remain/n) * n;
            if(remain > 0)
            {
                res += Math.min(c, remain*d);
            }
        }
        else
        {
            res = d*remain;
        }

        out.println(res);
    }
}

/*
 * For thinking that we could be something for real? Now am I wrong?
 *
 * For trying to reach the things that I can't see?
 *
 * But that's just how I feel,
 *
 * That's just how I feel
 *
 * That's just how I feel
 *
 * Trying to reach the things that I can't see
 */

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author DELL
 */
public class main {

    public static void main(String args[]) throws IOException {
        BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
        String s = x.readLine();
        String s1[] = s.split(" ");
        int c = Integer.parseInt(s1[0]);
        int d = Integer.parseInt(s1[1]);
        s = x.readLine();
        String s2[] = s.split(" ");
        int n = Integer.parseInt(s2[0]);
        int m = Integer.parseInt(s2[1]);
        int k = Integer.parseInt(x.readLine());
        int total = n * m;
        int t = total - k;
        if (t == 0) {
            System.out.println(t);
            return;
        }
        int res = 0;
        int a = 0;
        int b = 0;
        if (c <= d) {
            b = 0;
            a = t / n;
            if (t % n != 0) {
                a++;
            }
        } else {
            a = t / n;
            if (t % n != 0) {
                b = t % n;
            }
            if (d * b > c) {
                b = 0;
                a++;
            }
        }
        res = c * a + d * b;
        System.out.println(res);
    }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author PrateekNischal
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Elimination solver = new Elimination();
		solver.solve(1, in, out);
		out.close();
	}
}

class Elimination {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int lim = n*m - k;
        int res = 0;
        while (lim > 0)
        {
            if (c <= n*d) {
                lim -= n;
                res += c;
            }
            else{
                lim -= n;
                res += n*d;
            }
        }
        out.println(res);
    }
}

class InputReader
{
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    public int bufferSize = 32768;
    public InputReader(InputStream stream)
    {
        reader = new BufferedReader(new InputStreamReader(stream), bufferSize);
        tokenizer = null;
    }

    public String next()
    {
        while (tokenizer == null || !tokenizer.hasMoreTokens()){
            try{
                tokenizer = new StringTokenizer(reader.readLine());
            }catch(IOException e){throw new RuntimeException(e);}
        }
        return tokenizer.nextToken();
    }

    public int nextInt(){
        return Integer.parseInt(next());
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.*;

public class Round260 {

    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(in, out);
        out.close();
    }
}

/*
 * Am I wrong for thinking out the box from where I stay? Am I wrong for saying
 * that I choose another way?
 *
 * I ain't trying to do what everybody else doing Just cause everybody doing
 * what they all do
 *
 * If one thing I know, I'll fall but I'll grow
 *
 * I'm walking down this road of mine, this road that I call home
 *
 * So am I wrong?
 */

class TaskC {

    public void solve(InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();

        long res = 0;

        long remain = n * m - k;
        if (remain <= 0) {
            out.println(0);
            return;
        }

        int main = n/c;
        if (main <= 1) {
            res = (remain / n) * c;
            remain -= (remain/n) * n;
            if(remain > 0)
            {
                res += Math.min(c, remain*d);
            }
        }
        else
        {
            res = d*remain;
        }

        out.println(res);
    }
}

/*
 * For thinking that we could be something for real? Now am I wrong?
 *
 * For trying to reach the things that I can't see?
 *
 * But that's just how I feel,
 *
 * That's just how I feel
 *
 * That's just how I feel
 *
 * Trying to reach the things that I can't see
 */

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class elimination {
public static void main(String[] args) throws IOException {
	BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
	String p=bf.readLine();
	String []h=p.split(" ");
	int c=Integer.parseInt(h[0]);
	int d=Integer.parseInt(h[1]);
	 p=bf.readLine();
	 h=p.split(" ");
	int n=Integer.parseInt(h[0]);
	int m=Integer.parseInt(h[1]);
	int k=Integer.parseInt(bf.readLine());
	int sumPeople=(n*m)-k;
	int x=sumPeople*d;
	int y=0;
	int sum=0;
	int temp;
	while(sum<sumPeople)
	{
		temp=(sumPeople-sum)*d;
		if(temp<c)
		{
			y+=temp;
			break;
		}
		sum+=n;
		y+=c;
	}
	if(x<y)
	{
		System.out.println(x);
	}
	else
	{
		System.out.println(y);
	}
}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author rabeckiy
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int cm = n*m - k;
        if(cm == 0)
            out.println(0);
        else {
            int cc = (int)Math.floor(cm/n);
            int cd = (cm-cc*n) > 0?1:0;
            out.println(cc+cd);
        }
    }
}

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

public class RCCDiv2A {

	public static void main(String[] args) {

		int c = 0, d = 0, n = 0, m = 0, k = 0;
		Scanner in = new Scanner(System.in);

		c = in.nextInt();
		d = in.nextInt();
		n = in.nextInt();
		m = in.nextInt();
		k = in.nextInt();

		int fin = n*m, problem = 0;

		fin -= k;

		if (fin <= 0) {
			System.out.println(problem);
			return;
		}

		System.out.println(c*(int)(Math.ceil((double)fin/n)));
	}

}

import java.io.*;
import java.util.*;
import java.util.logging.Logger;

import static java.lang.System.*;

public class A417{
    static BufferedReader br;
    static  long mod  = 998244353;
    static HashSet<Integer> p  = new HashSet<>();
    public static void main(String[] args) throws Exception {
        br = new BufferedReader(new InputStreamReader(System.in));

        int testcCase = 1;
        //    testcCase = cinI();
        while (testcCase-- > 0) {

               int[] cd= readArray(2,0,0);
               int c =  cd[0];int d = cd[1];

               int[] nm = readArray(2,0,0);
                int n =nm[0];int m  =nm[1];

                int k  =cinI();

                int total  = n*m;
                total = total-k;

                int min = min(c,d*n);
          //  System.out.println(min +" "+c+" "+d*n);

                       int p  =total/n;
                       if(total%n!=0){
                           p+=1;
                       }
                    System.out.println(p*min);
                    exit(0);

        }

    }

    public static long min(long a,long b) {
        return Math.min(a,b);
    }
    public static int min(int a,int b) {
        return Math.min(a,b);
    }
    public  static  int[] readArray(int n,int x ,int z)throws Exception{
        int[] arr= new int[n];
        //   System.out.println(arr.length);
        String[] ar= cinA();
        for(int i =x ;i<n;i++){
            //   System.out.println(i-x);
            //  int  y  =getI(ar[i-x]);
            arr[i]=getI(ar[i-x]);
        }
        return arr;
    }
    public  static  long[] readArray(int n,int x )throws Exception{
        long[] arr= new long[n];
        String[] ar= cinA();
        for(int i =x ;i<n+x;i++){
            arr[i]=getL(ar[i-x]);
        }
        return arr;
    }

    public static void arrinit(String[] a,long[] b)throws Exception{
        for(int i=0;i<a.length;i++){
            b[i]=Long.parseLong(a[i]);
        }
    }
    public  static HashSet<Integer>[]  Graph(int n,int edge,int directed)throws Exception{
        HashSet<Integer>[] tree=  new HashSet[n];

        for(int j=0;j<edge;j++){

            String[] uv = cinA();
            int u = getI(uv[0]);
            int v = getI(uv[1]);
            if(directed==0){

                tree[v].add(u);
            }
            tree[u].add(v);
        }
        return tree;
    }
    public static void arrinit(String[] a,int[] b)throws Exception{
        for(int i=0;i<a.length;i++){
            b[i]=Integer.parseInt(a[i]);
        }
    }
    static double findRoots(int a, int b, int c) {
        // If a is 0, then equation is not
        //quadratic, but linear

        int d = b * b - 4 * a * c;
        double sqrt_val = Math.sqrt(Math.abs(d));

        // System.out.println("Roots are real and different \n");

        return Math.max((double) (-b + sqrt_val) / (2 * a),
                (double) (-b - sqrt_val) / (2 * a));

    }

    public static String cin() throws Exception {
        return br.readLine();
    }

    public static String[] cinA() throws Exception {
        return br.readLine().split(" ");
    }
    public static String[] cinA(int x) throws Exception{
        return br.readLine().split("");
    }

    public static String ToString(Long x) {
        return Long.toBinaryString(x);
    }

    public static void cout(String s) {
        System.out.println(s);
    }

    public static Integer cinI() throws Exception {
        return Integer.parseInt(br.readLine());
    }

    public static int getI(String s) throws Exception {
        return Integer.parseInt(s);
    }

    public static long getL(String s) throws Exception {
        return Long.parseLong(s);
    }

    public static long max(long a, long b) {
        return Math.max(a, b);
    }
    public static int max(int a, int b) {
        return Math.max(a, b);
    }

    public static void coutI(int x) {
        System.out.println(String.valueOf(x));
    }

    public static void coutI(long x) {
        System.out.println(String.valueOf(x));
    }

    public static Long cinL() throws Exception {
        return Long.parseLong(br.readLine());
    }

    public static void arrInit(String[] arr, int[] arr1) throws Exception {
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = getI(arr[i]);
        }

    }
}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt();
		int d = sc.nextInt();
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
int result = 0;
int total = n*m-k;
	if(total>0){

		if( n*1.0/c > 1.0/d ){
			while(total>=0){
				result+=c;
				total-=n;
			}
		}else{
			result+=total;
		}
	}
	System.out.println(result);
	}
}

import java.util.*;
public class Elimination {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt(), d = sc.nextInt(), n = sc.nextInt(), m = sc.nextInt(), k = sc.nextInt();
		int min = n*m - k;
		int q = 0;
		while(min >= n){
			q += Math.min(c, n*d);
			min -= n;
		}
		q += Math.min(c, min*d);
		System.out.println(q);
	}

}

/*******************************************************************
My love has gone away,
quietly after a hundered days.
This is what's she has always said she won't stay
for more than what she can repay.

I can still hear her say there
that I'm not hearing tender play
The day she let me kiss her was a display,
of love to those who she betray.

How can I put someone to the test,
when I thought I got the best.
Untill the taste of bitterness then I regret
but still that I won't detest,
the love I can't forget,
like someone who has left.

How can i leave someone for the rest
when i'm alone facing the best
Untill they take some try to reason i regret
But still that i won't detest
who i can never forget
like someone i once met ..
 ******************************************************************/
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

public class TaskA_417 {
	public static void main(String[] args) {
		input();
		solve();
	}

	static void solve() {
		int res = 0;
		int count = 0;
		int max = m * n - k;
		if (c > d * n) {
			while (count < max) {
				res += d;
				count++;
			}
		} else {
			while (count < max) {
				res += c;
				count += n;
			}
		}
		System.out.println(res);
	}

	/************************************************************************************/
	static int c;
	static int d;
	static int n;
	static int m;
	static int k;

	static void input() {
		c = nextInt();
		d = nextInt();
		n = nextInt();
		m = nextInt();
		k = nextInt();
	}

	/************************************************************************************/
	static InputStream is = System.in;
	static private byte[] buffer = new byte[1024];
	static private int lenbuf = 0, ptrbuf = 0;

	static private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = is.read(buffer);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return buffer[ptrbuf++];
	}

	static private boolean isSpace(int c) {
		return !(c >= 33 && c <= 126);
	}

	static private int read() {
		int b;
		while ((b = readByte()) != -1 && isSpace(b))
			;
		return b;
	}

	static private double nextDouble() {
		return Double.parseDouble(nextString());
	}

	static private char nextChar() {
		return (char) read();
	}

	static private String nextString() {
		int b = read();
		StringBuilder sb = new StringBuilder();
		while (!(isSpace(b))) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	static private char[] nextString(int n) {
		char[] buf = new char[n];
		int b = read(), p = 0;
		while (p < n && !(isSpace(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	static private int nextInt() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nextLong() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	static private int[] nextAi(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main {

    IIO io;

    Main(IIO io) {
        this.io = io;
    }

    public static void main(String[] args) throws IOException {

        ConsoleIO io = new ConsoleIO();
        Main m = new Main(io);
        m.solve();
        io.flush();

//        Tester test = new Tester();test.run();
    }

    public void solve() {
        int[] l = io.readIntArray();
        int c = l[0], d = l[1];
        l = io.readIntArray();
        int n = l[0], m = l[1];
        int k = io.readInt();
        int v = n * m;
        v -= k;
        if (k <= 0) {
            io.writeLine("0");
        } else {
            int f = v / n;
            v %= n;
            int res = Math.min(c * f, d * f * n) + Math.min(c, d * v);
            io.writeLine(Integer.toString(res));
        }
    }

}

class ConsoleIO extends BaseIO {
    BufferedReader br;
    PrintWriter out;
    public ConsoleIO(){
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }
    public void flush(){
        this.out.close();
    }
    public void writeLine(String s) {
        this.out.println(s);
    }
    public void writeInt(int a) {
        this.out.print(a);
        this.out.print(' ');
    }
    public void writeWord(String s){
        this.out.print(s);
    }
    public String readLine() {
        try {
            return br.readLine();
        }
        catch (Exception ex){
            return "";
        }
    }
    public int read(){
        try {
            return br.read();
        }
        catch (Exception ex){
            return -1;
        }
    }
}
abstract class BaseIO implements IIO {

    public long readLong() {
        return Long.parseLong(this.readLine());
    }

    public int readInt() {
        return Integer.parseInt(this.readLine());
    }

    public int[] readIntArray() {
        String line = this.readLine();
        String[] nums = line.split(" ");
        int[] res = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            res[i] = Integer.parseInt(nums[i]);
        }
        return res;
    }
    public long[] readLongArray() {
        String line = this.readLine();
        String[] nums = line.split(" ");
        long[] res = new long[nums.length];
        for (int i = 0; i < nums.length; i++) {
            res[i] = Long.parseLong(nums[i]);
        }
        return res;
    }
}
interface IIO {
    void writeLine(String s);
    void writeInt(int a);
    void writeWord(String s);
    String readLine();
    long readLong();
    int readInt();
    int read();
    int[] readIntArray();
    long[] readLongArray();
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author rabeckiy
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int cm = n*m - k;
        if(cm == 0)
            out.println(0);
        else {
            int cc = (int)Math.floor(cm/n);
            int cd = (cm-cc) > 0?1:0;
            out.println(cc+cd);
        }
    }
}

import java.util.Scanner;

public class test {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int c = input.nextInt();
        int d = input.nextInt();
        int n = input.nextInt();
        int m = input.nextInt();
        int k = input.nextInt();
        input.close();
        int num = n * m;
        int people = num - k;
        if (people != 0) {
            int res1 = c * ((people - 1)/ n + 1);
            int res2 = (c + d) * ((people - 1) / (n + 1) + 1);
            if (res1 < res2)
                System.out.print(res1);
            else
                System.out.print(res2);
        }
        else
            System.out.print(0);
    }
}

import java.io.*;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;

public class CodeForces {

	public void solve() throws IOException {
		int c = nextInt();
		int d = nextInt();
		int n = nextInt();
		int m = nextInt();
		int k = nextInt();

		int res = Integer.MAX_VALUE;
		int nm = n * m - k;

		for (int i = 0; i < nm / n + 1; i++) {
			for (int j = 0; j < nm + 1; j++) {
				if(i*n+j>=nm){
					res = Math.min(res, i*c+j*d);
				}
			}
		}

		System.out.println(res);
	}

	public static void main(String[] args) {
		new CodeForces().run();
	}

	int NOD(int a, int b) {
		while (a != 0 && b != 0) {
			if (a >= b)
				a = a % b;
			else
				b = b % a;
		}
		return a + b;
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	boolean isOuterFile = false;

	public void run() {
		try {
			if (isOuterFile) {
				reader = new BufferedReader(new FileReader(
						"C:\\work\\javaprojects\\CodeForces\\SCC.txt"));
				// out = new PrintWriter(new BufferedWriter(new FileWriter(
				// "output.txt")));
				// out = new PrintWriter(System.out);
			} else {
				reader = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			tokenizer = null;

			// long time = System.currentTimeMillis();
			solve();
			// out.println(System.currentTimeMillis() - time);
			reader.close();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author rabeckiy
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int need = n*m - k;
        if(need == 0)
            out.println(0);
        else {
            int cc = need>=n?1:0;
            int cd = (need%n) > 0?1:0;
            out.println(cc+cd);
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class A {
    public static void main(String[] args) throws IOException {
        BufferedReader input =
			new BufferedReader(new InputStreamReader(System.in));
		String[] cd = input.readLine().split(" ");
		String[] nm = input.readLine().split(" ");
		int k = Integer.parseInt(input.readLine());
		int c = Integer.parseInt(cd[0]);
		int d = Integer.parseInt(cd[1]);
		int n = Integer.parseInt(nm[0]);
		int m = Integer.parseInt(nm[1]);
		int s = n*m - k;
		int min = Integer.MAX_VALUE;
		for (int i = 0; i <= s/n + 1; i++) {
		    if (min > i * c + Math.max(s - i*n,0) * d)
		        min = i * c + Math.max(s - i*n,0) * d;
		}
		System.out.println(min);
    }
}

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    class Input {
        BufferedReader bf;
        StringTokenizer st;

        Input(InputStream stream) throws IOException {
            bf = new BufferedReader(new InputStreamReader(stream));
            st = new StringTokenizer("");
        }

        int nextInt() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());

            return Integer.parseInt(st.nextToken());
        }

        long nextLong() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Long.parseLong(st.nextToken());
        }

        double nextDouble() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Double.parseDouble(st.nextToken());
        }

        void readLine() throws IOException {
            st = new StringTokenizer(bf.readLine());
        }

        String nextString() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        String nextLine() throws IOException {
            return bf.readLine();
        }

        void close() throws IOException {
            bf.close();
        }
    }

    Input in;

    public class Problem {

        class Point implements Comparable<Point> {
            int x, y, p;

            Point(int a, int b, int k) {
                x = a;
                y = b;
                p = k;
            }

            @Override
            public int compareTo(Point o) {
                return Integer.compare(this.x, o.x);
            }
        }

        @SuppressWarnings("deprecation")
        public void solve() throws IOException {

            int c = in.nextInt();
            int d = in.nextInt();
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            int s = Math.max(n * m - k, 0);

            int x = Math.max(s / n, 1);

            int res = x * c;

            if (n * m > x * n + k) {
                res += Math.min(s % n, c);
            }

            System.out.println(res);
        }
    }

    public void solveProblem() throws IOException {

        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        in = new Input(oj ? System.in : new FileInputStream("//home/bamboo/GitProjects/studyDir/Acm/input.txt"));

        // in = new Input(System.in);
        // in = new Input(new FileInputStream("D:/Codes/Java/input.txt"));
        new Problem().solve();
        in.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().solveProblem();
    }

}

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    class Input {
        BufferedReader bf;
        StringTokenizer st;

        Input(InputStream stream) throws IOException {
            bf = new BufferedReader(new InputStreamReader(stream));
            st = new StringTokenizer("");
        }

        int nextInt() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());

            return Integer.parseInt(st.nextToken());
        }

        long nextLong() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Long.parseLong(st.nextToken());
        }

        double nextDouble() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Double.parseDouble(st.nextToken());
        }

        void readLine() throws IOException {
            st = new StringTokenizer(bf.readLine());
        }

        String nextString() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        String nextLine() throws IOException {
            return bf.readLine();
        }

        void close() throws IOException {
            bf.close();
        }
    }

    Input in;

    public class Problem {

        class Point implements Comparable<Point> {
            int x, y, p;

            Point(int a, int b, int k) {
                x = a;
                y = b;
                p = k;
            }

            @Override
            public int compareTo(Point o) {
                return Integer.compare(this.x, o.x);
            }
        }

        @SuppressWarnings("deprecation")
        public void solve() throws IOException {

            int c = in.nextInt();
            int d = in.nextInt();
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            int s = Math.max(n * m - k, 0);
            int res = 0;

            if (c < d * n) {
                int x = s / n;

                res = x * c;

                s %= n;
            }

            if (s > 0) {
                res += Math.min(s * d, c);
            }

            System.out.println(res);
        }
    }

    public void solveProblem() throws IOException {

        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        in = new Input(oj ? System.in : new FileInputStream("//home/bamboo/GitProjects/studyDir/Acm/input.txt"));

        // in = new Input(System.in);
        // in = new Input(new FileInputStream("D:/Codes/Java/input.txt"));
        new Problem().solve();
        in.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().solveProblem();
    }

}

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

public class RCCDiv2A {

	public static void main(String[] args) {

		int c = 0, d = 0, n = 0, m = 0, k = 0;
		Scanner in = new Scanner(System.in);

		c = in.nextInt();
		d = in.nextInt();
		n = in.nextInt();
		m = in.nextInt();
		k = in.nextInt();

		int fin = n*m, problem = 0;

		fin -= k;

		if (fin <= 0) {
			System.out.println(problem);
			return;
		}

		System.out.println(d*(n - fin % n) + (c*(int)(Math.ceil((double)fin/n)))-1);
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class elimination {
public static void main(String[] args) throws IOException {
	BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
	String p=bf.readLine();
	String []h=p.split(" ");
	int c=Integer.parseInt(h[0]);
	int d=Integer.parseInt(h[1]);
	 p=bf.readLine();
	 h=p.split(" ");
	int n=Integer.parseInt(h[0]);
	int m=Integer.parseInt(h[1]);
	int k=Integer.parseInt(bf.readLine());
	int sumPeople=(n*m)-k;
	int x=sumPeople*d;
	int y=0;
	int sum=0;
	while(sum<sumPeople)
	{
		sum+=n;
		y+=c;
	}
	if(x<y)
	{
		System.out.println(x);
	}
	else
	{
		System.out.println(y);
	}
}
}

import java.util.Scanner;

public class Input {

    public static void main(String[] args) {

        int c,d,m,n,k;
        int winners, questions = 0, left;
        @SuppressWarnings("resource")
        Scanner in = new Scanner(System.in);

        c = in.nextInt();
        d = in.nextInt();
        n = in.nextInt();
        m = in.nextInt();
        k = in.nextInt();

        winners = m*n - k;
        if (winners == 0) {
            questions = 0;
        } else {
            float f = c/d;
            if (f < n) {
                questions = (int) (Math.floor(winners/n) * c);
                left = winners%n;
                if (left*d < c) questions += left*d;
                else questions += c;
            }
        }
        System.out.println((questions >= 0) ? questions : 0);

    }

}

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

public class p417c
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        if(n>=2*k+1)
        {
            System.out.println(n*k);
            for(int i=1;i<n;i++)
            {
                for(int j=1;j<=k;j++)
                {
                    if(i+j>n) System.out.println(i+" "+((i+j)%n));
                    else System.out.println(i+" "+(i+j));
                }
            }
            for(int i=1;i<=k;i++)
            {
                System.out.println(n+" "+i);
            }
        }
        else System.out.println("-1");
    }
}

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

public class SolutionA {
	public void solve(){
		int firstRound = nextInt(), secondRound = nextInt();
		int n = nextInt(), m = nextInt();
		int k = nextInt();
		int needs = n * m - k;
		out.println(firstRound * ((needs + n - 1) /  n));

	}

	public void run(){
		solve();
		out.close();
	}
	public static void main(String args[]){
		new SolutionA().run();
	}
	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	PrintWriter out = new PrintWriter(System.out);
	String line;
	StringTokenizer st;
	public String nextLine(){
		try {
			line = bf.readLine();
			st = new StringTokenizer(line);
		} catch (IOException e) {
			return null;
		}
		return line;
	}
	public String nextString(){
		while (st == null || !st.hasMoreElements()) {
            try {
                line = bf.readLine();
                st = new StringTokenizer(line);
            } catch (IOException e) {
                return null;
            }
        }
        return st.nextToken();
	}
	public int nextInt(){
		return Integer.parseInt(nextString());
	}
	public long nextLong(){
		return Long.parseLong(nextString());
	}
	public double nextDouble(){
		return Double.parseDouble(nextString());
	}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author rabeckiy
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int cm = n*m - k;
        int cc = (int)Math.floor(cm/n)>0?1:0;
        int cd = (cm-cc) > 0?1:0;
        out.println(cc+cd);
    }
}

import java.util.Scanner;

public class Input {

    public static void main(String[] args) {

        int c,d,m,n,k;
        int winners, questions = 0, left;
        @SuppressWarnings("resource")
        Scanner in = new Scanner(System.in);

        c = in.nextInt();
        d = in.nextInt();
        n = in.nextInt();
        m = in.nextInt();
        k = in.nextInt();

        winners = m*n - k;
        if (winners == 0) {
            questions = 0;
        } else {
            float f = c/d;
            if (f < n) {
                questions = (int) (Math.floor(winners/n) * c);
                left = winners%n;
                if (left*d < c) questions += left*d;
                else questions += c;
            } else {
            	questions += winners;
            }
        }
        System.out.println((questions >= 0) ? questions : 0);

    }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.StringTokenizer;

public class RCC_A {
	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		Locale.setDefault(Locale.US);
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int c = nextInt(), d = nextInt();
		int n = nextInt(), m = nextInt();
		int k = nextInt();
		int uchas = n * m - k;
		int min = 1000000;
		for (int i = 0; i <= 1000; i++) {
			for (int j = 0; j <= 1000; j++) {
				if (i * n + j >= uchas) {
					min = Math.min(min, i * c + j * d);
				}
			}
		}
		pw.println(min);
		pw.close();
	}

	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	private static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class T417A {

	public int solve(int c, int d, int n, int m, int k) {
		int res = n * m - k;

		if (res == 1) return 0;

		int ans = 0;
		while (res > 0) {
			if (res >= n) {
				ans += Math.min(c, d * n);
				res -= n;
			} else {
				//ans += Math.min(c, d * res);
				res = 0;
			}
		}
		return ans;
	}
	public static void main(String[] args) {
		FastScanner in = new FastScanner();
		System.out.println(new T417A().solve(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt()));

	}
	static class FastScanner {

		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

	}
}

import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class Main {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
    	if (ONLINE_JUDGE) {
    	in = new BufferedReader(new InputStreamReader(System.in));
    	out = new PrintWriter(System.out);
    	} else {
    	in = new BufferedReader(new FileReader("input.txt"));
    	out = new PrintWriter("output.txt");
    	}
    	}

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    public static void main(String[] args) {
        new Main().run();
        // Sworn to fight and die
    }

    public static void mergeSort(int[] a) {
        mergeSort(a, 0, a.length - 1);
    }

    private static void mergeSort(int[] a, int levtIndex, int rightIndex) {
        final int MAGIC_VALUE = 50;
        if (levtIndex < rightIndex) {
            if (rightIndex - levtIndex <= MAGIC_VALUE) {
                insertionSort(a, levtIndex, rightIndex);
            } else {
                int middleIndex = (levtIndex + rightIndex) / 2;
                mergeSort(a, levtIndex, middleIndex);
                mergeSort(a, middleIndex + 1, rightIndex);
                merge(a, levtIndex, middleIndex, rightIndex);
            }
        }
    }

    private static void merge(int[] a, int levtIndex, int middleIndex,
            int rightIndex) {
        int length1 = middleIndex - levtIndex + 1;
        int length2 = rightIndex - middleIndex;
        int[] levtArray = new int[length1];
        int[] rightArray = new int[length2];
        System.arraycopy(a, levtIndex, levtArray, 0, length1);
        System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
        for (int k = levtIndex, i = 0, j = 0; k <= rightIndex; k++) {
            if (i == length1) {
                a[k] = rightArray[j++];
            } else if (j == length2) {
                a[k] = levtArray[i++];
            } else {
                a[k] = levtArray[i] <= rightArray[j] ? levtArray[i++]
                        : rightArray[j++];
            }
        }
    }

    private static void insertionSort(int[] a, int levtIndex, int rightIndex) {
        for (int i = levtIndex + 1; i <= rightIndex; i++) {
            int current = a[i];
            int j = i - 1;
            while (j >= levtIndex && a[j] > current) {
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = current;
        }
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    class LOL implements Comparable<LOL> {
    	 int x;

        @Override
        public int compareTo(LOL o) {

            return x - o.x; // ---->
            // return o.x - x; // <----
            // return o.y-y;
        }

        public void setX(int u) {
        	this.x=u;
        }

    }

    public int gcd(int a, int b) {
    	if (a%b==0) return b;
    	else return gcd(b,a%b);
    }

     public double min(double a,double b) {
    	 if (a>b) return b;
    	 else return a;
     }
    public void solve() throws IOException {

    	int c=readInt();
    	int d=readInt();
    	int n=readInt();
    	int m=readInt();
    	int k=readInt();
    	int min = 1000000;

    	for (int x=0; x<=m; x++)
    		for (int y=0; y<=m*n-k; y++)
    			if (n*x+y+k>=n*m)
    				if(c*x+d*y<min) {
    					min=c*x+d*y;

    				}

    	out.print(min);
}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.StringTokenizer;

public class RCC_A {
	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		Locale.setDefault(Locale.US);
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int c = nextInt(), d = nextInt();
		int n = nextInt(), m = nextInt();
		int k = nextInt();
		if (n * m - k > c + d)
			System.out.println((n * m - k) - (c + d));
		else {
			System.out.println(0);
		}
		pw.close();
	}

	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	private static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}

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

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf417a {

    public static void main(String[] args) throws IOException {
        int c = rni(), d = ni(), n = rni(), m = ni(), k = ri(), need = n * m - k;
        if (need <= 0) {
            prln(0);
        } else if (n * d > c) {
            prln(min(need / n * c + need % n * m, (need / n + 1) * c));
        } else {
            prln(need * m);
        }
        close();
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random __rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IMAX ~= 2e9
    // LMAX ~= 9e18

    // constants
    static final int IBIG = 1000000007;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // math util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int fli(double d) {return (int)d;}
    static int cei(double d) {return (int)ceil(d);}
    static long fll(double d) {return (long)d;}
    static long cel(double d) {return (long)ceil(d);}
    static int gcf(int a, int b) {return b == 0 ? a : gcf(b, a % b);}
    static long gcf(long a, long b) {return b == 0 ? a : gcf(b, a % b);}
    static int lcm(int a, int b) {return a * b / gcf(a, b);}
    static long lcm(long a, long b) {return a * b / gcf(a, b);}
    static int randInt(int min, int max) {return __rand.nextInt(max - min + 1) + min;}
    static long hash(long x) {x += 0x9e3779b97f4a7c15L; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9L; x = (x ^ (x >> 27)) * 0x94d049bb133111ebL; return x ^ (x >> 31);}
    // array util
    static void reverse(int[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {int swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(long[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {long swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(char[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {char swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void rsort(int[] a) {shuffle(a); sort(a);}
    static void rsort(long[] a) {shuffle(a); sort(a);}
    static int[] copy(int[] a) {int[] ans = new int[a.length]; for(int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    static long[] copy(long[] a) {long[] ans = new long[a.length]; for(int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    static char[] copy(char[] a) {char[] ans = new char[a.length]; for(int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    // graph util
    static List<List<Integer>> g(int n) {List<List<Integer>> g = new ArrayList<>(); for(int i = 0; i < n; ++i) g.add(new ArrayList<>()); return g;}
    static List<Set<Integer>> sg(int n) {List<Set<Integer>> g = new ArrayList<>(); for(int i = 0; i < n; ++i) g.add(new HashSet<>()); return g;}
    static void c(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).add(v); g.get(v).add(u);}
    static void cto(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).add(v);}
    static void dc(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).remove(v); g.get(v).remove(u);}
    static void dcto(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).remove(v);}
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static int[] riam1(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()) - 1; return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    static List<List<Integer>> rg(int n, int m) throws IOException {List<List<Integer>> g = g(n); for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1); return g;}
    static void rg(List<List<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1);}
    static List<List<Integer>> rdg(int n, int m) throws IOException {List<List<Integer>> g = g(n); for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1); return g;}
    static void rdg(List<List<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1);}
    static List<Set<Integer>> rsg(int n, int m) throws IOException {List<Set<Integer>> g = sg(n); for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1); return g;}
    static void rsg(List<Set<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1);}
    static List<Set<Integer>> rdsg(int n, int m) throws IOException {List<Set<Integer>> g = sg(n); for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1); return g;}
    static void rdsg(List<Set<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1);}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); if(n >= 0) __out.println(iter.next()); else __out.println();}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt();
		int d = sc.nextInt();
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		int min_que = Integer.MAX_VALUE;
		int total = n * m - k;
		int que_count = 0;
		if (total <= 0) {
			System.out.println(0);
			return;
		}
		for (int i = 1; i <= m; i++) {
			if (total - i * n > 0)
				que_count = i * c + (total - i * n) * d;
			else {
				que_count = i * c;
			}
			min_que = Math.min(que_count, min_que);
		}
		System.out.println(min_que);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/**
 * Created by Vadim_2 on 20.04.2014.
 */
public class A1 {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(reader.readLine());

        int c = Integer.parseInt(st.nextToken());
        int d = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(reader.readLine());

        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(reader.readLine());
        int k = Integer.parseInt(st.nextToken());
        if(k>=n*m) {
            System.out.println(0);
        } else
        if(d<=c/n) {
            System.out.println((n*m - k) * d);
        } else {
            System.out.println((n*m - k)/n*c + (((n*m - k) % n != 0) ? c: 0) );
        }
    }
}

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

/**
 * @author master_j
 */
public class Solution {
    private IO io;
    private static final String _localArg = "master_j";
    private final String _problemName = "";
    private final int _inMode = IO.STD_;
    private final int _outMode = IO.STD_;
    private final boolean _autoFlush = false;

    private void solve() throws IOException {
        int c = io.nI(), d = io.nI();
        int n = io.nI(), m = io.nI();
        int k = io.nI();
        int ans = Integer.MAX_VALUE;

        for(int dop = 0; dop <= n*m; dop++)
            for(int osn = 1; osn <= n*m; osn++)
                if(n*m <= k + osn*n + dop)
                    ans = Math.min(ans, osn*c + dop*d);

        io.wln(ans);
    }//2.2250738585072012e-308

    private void init(boolean local) throws IOException {
        if(local)
            io = new IO(IO._PUT_TXT, IO.STD_);
        else{
            if((_inMode == IO.PROBNAME_ || _outMode == IO.PROBNAME_) && _problemName.length() == 0)
                throw new IllegalStateException("You imbecile. Where's my <_problemName>?");
            io = new IO(_inMode, _outMode);
        }

        long nanoTime = 0;
        if(local){
            nanoTime -= System.nanoTime();
            if(_autoFlush)
                io.wln("NOTE: auto-flush is on.");
            io.wln("<output>");
            io.flush();
        }

        solve();
        io.flush();

        if(local){
            io.wln("</output>");
            nanoTime += System.nanoTime();
            long d9 = 1000000000, d6 = 1000000, d3 = 1000;
            if(nanoTime >= d9)
                io.wf("%d.%d seconds\n", nanoTime/d9, nanoTime%d9);
            else if(nanoTime >= d6)
                io.wf("%d.%d millis\n", nanoTime/d6, nanoTime%d6);
            else if(nanoTime >= d3)
                io.wf("%d.%d micros\n", nanoTime/d3, nanoTime%d3);
            else
                io.wf("%d nanos\n", nanoTime);
            io.flush();
        }

        io.close();
    }

    /**
     * Input-output class
     *
     * @author master_j
     * @version 0.3.2
     */
    private class IO {
//     _____________________________ _________________
//    |  mode  |      from/to       |  variable name  |
//    |--------|--------------------|-----------------|
//    |    0   |      System.*      |       STD_      |
//    |    1   |      *put.txt      |     _PUT_TXT    |
//    |    2   |  <_problemName>.*  |     PROBNAME_   |
//    |________|____________________|_________________|
//

        static final int STD_ = 0;
        static final int _PUT_TXT = 1;
        static final int PROBNAME_ = 2;

        StreamTokenizer st;
        BufferedReader br;
        Reader reader;

        PrintWriter pw;
        Writer writer;

        IO(int inMode, int outMode) throws IOException {
            Locale.setDefault(Locale.US);

            if(inMode == IO.STD_)
                reader = new InputStreamReader(System.in);
            else if(inMode == IO._PUT_TXT)
                reader = new FileReader("input.txt");
            else if(inMode == IO.PROBNAME_)
                reader = new FileReader(_problemName + ".in");
            else
                throw new IllegalStateException("You imbecile. How did you do that?");

            if(outMode == IO.STD_)
                writer = new OutputStreamWriter(System.out);
            else if(outMode == IO._PUT_TXT)
                writer = new FileWriter("output.txt");
            else if(outMode == IO.PROBNAME_)
                writer = new FileWriter(_problemName + ".out");
            else
                throw new IllegalStateException("You imbecille. Why did you do that?");

            br = new BufferedReader(reader);
            st = new StreamTokenizer(br);

            pw = new PrintWriter(writer, _autoFlush);
        }

        void wln()          {pw.println(); }
        void wln(boolean x) {pw.println(x);}
        void wln(char x)    {pw.println(x);}
        void wln(char x[])  {pw.println(x);}
        void wln(double x)  {pw.println(x);}
        void wln(float x)   {pw.println(x);}
        void wln(int x)     {pw.println(x);}
        void wln(long x)    {pw.println(x);}
        void wln(Object x)  {pw.println(x);}
        void wln(String x)  {pw.println(x);}

        void wf(String f, Object...o){pw.printf(f, o);}

        void w(boolean x)   {pw.print(x);}
        void w(char x)      {pw.print(x);}
        void w(char x[])    {pw.print(x);}
        void w(double x)    {pw.print(x);}
        void w(float x)     {pw.print(x);}
        void w(int x)       {pw.print(x);}
        void w(long x)      {pw.print(x);}
        void w(Object x)    {pw.print(x);}
        void w(String x)    {pw.print(x);}

        int nI() throws IOException    {st.nextToken(); return (int)st.nval;}
        double nD() throws IOException {st.nextToken(); return st.nval;}
        float nF() throws IOException  {st.nextToken(); return (float)st.nval;}
        long nL() throws IOException   {st.nextToken(); return (long)st.nval;}
        String nS() throws IOException {st.nextToken(); return st.sval;}

        void wc(String x){ wc(x.toCharArray()); }
        void wc(char c1, char c2){for(char c = c1; c<=c2; c++)wc(c);}
        void wc(char x[]){
            for(char c : x)
                wc(c);
        }
        void wc(char x){st.ordinaryChar(x); st.wordChars(x, x);}

        public boolean eof() {return st.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol() {return st.ttype == StreamTokenizer.TT_EOL;}

        void flush(){pw.flush();}
        void close() throws IOException{reader.close(); br.close(); flush(); pw.close();}
    }

    public static void main(final String args[]) throws IOException {
        new Solution().init(args.length == 1 && args[0].equals(_localArg));
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double c = sc.nextDouble();
        double d = sc.nextDouble();
        double n = sc.nextDouble();
        double m = sc.nextDouble();
        double k = sc.nextDouble();

        double need = n*m-k;
        double mul;
        if(n/c > 1/d){
            mul = n/c;
        }else{
            mul = 1/d;
        }
        int count=0;
        while(need>0){
            need -= mul;
            count++;
        }
        System.out.println(count);
        sc.close();
    }
}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c=sc.nextInt(),d=sc.nextInt(), n=sc.nextInt(), m=sc.nextInt(), k=sc.nextInt();
		if(((n*m)-k) <= 0) {
			System.out.println(0);
			return;
		} else {
			System.out.println(Math.min(c * ((n*m)-k)/n, d * ((n*m)-k)/n * n) + Math.min(c, d * ((n*m)-k)%n));
		}
	}
}

import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author @thnkndblv
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();

        int n = in.nextInt();
        int m = in.nextInt();

        int k = in.nextInt();

        int target = n * m - k;

        int ans = m * c;

        for (int i = 0; i <= m; i++)
        {
            int mains = c * i;
            int rem = target - i * n;

            int adds = Math.max( 0, rem );

            ans = Math.min( ans, mains + adds );
        }

        out.println( ans );
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

import java.util.Scanner;

/**
 *
 * @author Hidayat
 */
public class Elimination {

    static int c, d, n;

    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        c = in.nextInt();
        d = in.nextInt();
        n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();

        int target = n * m - k;
        int result = target;

        System.out.println(result);

    }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author PrateekNischal
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Elimination solver = new Elimination();
		solver.solve(1, in, out);
		out.close();
	}
}

class Elimination {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int lim = n*m - k;
        int res = 0;
        while (lim >= n)
        {
            if (c <= n*d) {
                lim -= n;
                res += c;
            }
            else{
                lim -= n;
                res += n*d;
            }
        }
        res += Math.min(c, lim*d);
        out.println(res);
    }
}

class InputReader
{
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    public int bufferSize = 32768;
    public InputReader(InputStream stream)
    {
        reader = new BufferedReader(new InputStreamReader(stream), bufferSize);
        tokenizer = null;
    }

    public String next()
    {
        while (tokenizer == null || !tokenizer.hasMoreTokens()){
            try{
                tokenizer = new StringTokenizer(reader.readLine());
            }catch(IOException e){throw new RuntimeException(e);}
        }
        return tokenizer.nextToken();
    }

    public int nextInt(){
        return Integer.parseInt(next());
    }
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author rabeckiy
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int need = n*m - k;
        if(need == 0)
            out.println(0);
        else {
            int cc = need>=n?1:0;
            int cd = (need%n) > 0?1:0;
            out.println(cc+cd);
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.PriorityBlockingQueue;

import javax.swing.ComboBoxEditor;

public class aa {
	public static class node {
		int d;
		int t;

		node(int d, int t) {
			this.d = d;
			this.t = t;
		}
	}

	public static void solve() {

	}

	public static void main(String[] args) throws IOException {

		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder();
		String y[] = in.readLine().split(" ");
		int f = Integer.parseInt(y[0]);
		int s = Integer.parseInt(y[1]);
		y = in.readLine().split(" ");
		int num1 = Integer.parseInt(y[0]);
		int num2 = Integer.parseInt(y[1]);
		int k = Integer.parseInt(in.readLine());
		int ans = k;
		int limit = num1 * num2;
		int count = 0;
		if (ans < limit) {
			int e = limit - ans;
			int one = e / num1;
			int one1 = e % num1;
			count = one;
			if (one1 != 0) {
				int ans1 = one1 * s;
				int ans2 = f;
				count += Math.min(ans1, ans2);
			}

		}
		System.out.println(count);
		out.close();

	}
}

import java.util.*;
import static java.lang.Math.*;

public class Elimination
{
    public static void main(String []av) {
        Scanner s = new Scanner(System.in);
        int c = s.nextInt();    // <=100
        int d = s.nextInt();    // <=100
        int n = s.nextInt();    // <=100
        int m = s.nextInt();    // <=100
        int k = s.nextInt();    // <=100
        int need = n * m - k;   // <= 10000
        int cn = c * n;

        // c * x * n + d * y >= need
        // (x + y) -> min
        int _min = Integer.MAX_VALUE;
        for (int y = 0; y < 10001; y++) {
            // c * n * x >= need - d * y
            int dx = max(need - d * y, 0);
            while (dx % cn != 0)
                dx++;

            int x = dx / cn;
            _min = min(_min, x + y);
        }
        System.out.println(_min);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;

public class A241 {

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();

        int min = n*m;
        int need = 0;
        if(min>k){
            need = min-k;
        }else{
            System.out.println("0");
            System.exit(0);
        }
        if(need<n){
            if(d*need<c){
                System.out.println(d*need);
            }else{
                System.out.println(c);

            }
            System.exit(0);
        }
        int ans=0;
       // System.out.println("need = "+need);
        if(n*d<=c){
            //System.out.println("^^^^");
           // System.out.println(n*d);
            ans=(need/n)*d;
            //System.out.println("ans "+ans);
        }else {
            ans+=(need/n)*c;
            int rem = need%n;
            if(rem*d<c){
                ans+=rem*d;
            }else{
                ans+=c;
            }
        }

        System.out.println(ans);

    }

    public static void main(String[] args) throws IOException {
        new A241().solve();

    }
}

import java.io.*;
import java.util.StringTokenizer;

public class Main {
    class Input {
        BufferedReader bf;
        StringTokenizer st;

        Input(InputStream stream) throws IOException {
            bf = new BufferedReader(new InputStreamReader(stream));
            st = new StringTokenizer("");
        }

        int nextInt() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());

            return Integer.parseInt(st.nextToken());
        }

        long nextLong() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Long.parseLong(st.nextToken());
        }

        double nextDouble() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Double.parseDouble(st.nextToken());
        }

        void readLine() throws IOException {
            st = new StringTokenizer(bf.readLine());
        }

        String nextString() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        String nextLine() throws IOException {
            return bf.readLine();
        }

        void close() throws IOException {
            bf.close();
        }
    }

    Input in;

    public class Problem {

        class Point implements Comparable<Point> {
            int x, y, p;

            Point(int a, int b, int k) {
                x = a;
                y = b;
                p = k;
            }

            @Override
            public int compareTo(Point o) {
                return Integer.compare(this.x, o.x);
            }
        }

        @SuppressWarnings("deprecation")
        public void solve() throws IOException {

            int c = in.nextInt();
            int d = in.nextInt();
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            int s = Math.max(n * m - k, 0);

            int x = s / n;

            int res = x * c;

            s %= n;

            if (s > 0) {
                res += Math.min(s * d, c);
            }

            System.out.println(res);
        }
    }

    public void solveProblem() throws IOException {

        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        in = new Input(oj ? System.in : new FileInputStream("//home/bamboo/GitProjects/studyDir/Acm/input.txt"));

        // in = new Input(System.in);
        // in = new Input(new FileInputStream("D:/Codes/Java/input.txt"));
        new Problem().solve();
        in.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().solveProblem();
    }

}

import java.util.InputMismatchException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        if (k >= n * m) out.println(0);
        else if (m * c > n * m * d) out.println(n * m * d);
        else out.println(m * c);

    }
}

class InputReader {
    BufferedReader in;
    StringTokenizer st;

    public InputReader(InputStream stream) {
        in = new BufferedReader(new InputStreamReader(stream));
        eat("");
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public String next() {
        while (!st.hasMoreTokens())
            eat(nextLine());
        return st.nextToken();
    }

    public String nextLine() {
        try {
            return in.readLine();
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    public void eat(String str) {
        if (str == null) throw new InputMismatchException();
        st = new StringTokenizer(str);
    }
}

import java.util.*;
import java.lang.Math;

public class Main{
    public static void main(String[] args){
        Scanner myScanner = new Scanner(System.in);
        int c = myScanner.nextInt();
        int d = myScanner.nextInt();
        int n = myScanner.nextInt();
        int m = myScanner.nextInt();
        int k = myScanner.nextInt();
        int nCon = n * m - k, result = 10000000;
        for(int i = 0; i <= nCon; i++){
            for(int j = 0; j <= nCon; j++){
                int tempCon = i * n + j;
                if( tempCon >= nCon){
                    result = Math.min(result, i * c + d * j);
                }
            }
        }
        System.out.println(result);
    }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.StringTokenizer;

public class RCC_A {
	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;

	public static void main(String[] args) throws IOException {
		Locale.setDefault(Locale.US);
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		int c = nextInt(), d = nextInt();
		int n = nextInt(), m = nextInt();
		int k = nextInt();
		int uchas = n * m - k;
		int min = 1000000;
		for (int i = 0; i <= 1000; i++) {
			for (int j = 0; j <= 1000; j++) {
				if (i * n + j >= uchas) {
					min = Math.min(min, i * c + j * d);
				}
			}
		}
		pw.println(min);
		pw.close();
	}

	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	private static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;

public class A241 {

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();

        int min = n*m;
        int need = 0;
        if(min>k){
            need = min-k;
        }else{
            System.out.println("0");
            System.exit(0);
        }
        if(need<n){
            if(d*need<c){
                System.out.println(d*need);
            }else{
                System.out.println(c);

            }
            System.exit(0);
        }
        int ans=0;
       // System.out.println("need = "+need);
        if(n*d<=c){
            //System.out.println("^^^^");
           // System.out.println(n*d);
            ans=d;
            //System.out.println("ans "+ans);
        }else {
            ans+=(need/n)*c;
            int rem = need%n;
            if(rem*d<c){
                ans+=rem*d;
            }else{
                ans+=c;
            }
        }

        System.out.println(ans);

    }

    public static void main(String[] args) throws IOException {
        new A241().solve();

    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double c = sc.nextDouble();
        double d = sc.nextDouble();
        double n = sc.nextDouble();
        double m = sc.nextDouble();
        double k = sc.nextDouble();

        double need = n*m-k;
        double mul,mul2;
        int cnt,cnt2;
        int count=0;
        if(n/c > 1/d){
            mul = n; mul2 = 1;
            cnt = (int)c; cnt2 = (int)d;
            while(need>0){
//              System.out.println(need);
//              System.out.println(count);
                if(need>mul){
                    need -= mul;
                    count+=cnt;
                }else{
                    if((mul-need)*d<cnt){
                        count+=(int)(mul-need)*d;
                        break;
                    }else{
                        count+=cnt;
                        break;
                    }
                }
            }
        }else{
            mul = 1; mul2 = n;
            cnt = (int)d; cnt2 = (int)c;
            while(need>0){
                need -= mul;
                count+=cnt;
            }
        }

        System.out.println(count);
        sc.close();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.PriorityBlockingQueue;

import javax.swing.ComboBoxEditor;

public class aa {
	public static class node {
		int d;
		int t;

		node(int d, int t) {
			this.d = d;
			this.t = t;
		}
	}

	public static void solve() {

	}

	public static void main(String[] args) throws IOException {

		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		StringBuilder q = new StringBuilder();
		String y[] = in.readLine().split(" ");
		int f = Integer.parseInt(y[0]);
		int s = Integer.parseInt(y[1]);
		y = in.readLine().split(" ");
		int num1 = Integer.parseInt(y[0]);
		int num2 = Integer.parseInt(y[1]);
		int k = Integer.parseInt(in.readLine());
		int ans = k;
		int limit = num1 * num2;
		int e = limit - ans;
		int count1 = s * e;
		int count2 = (e / num1) * f;
		if (e % num1 != 0) {
			int t1 = s * (e % num1);
			int t2 = f;
			count2 += Math.min(t1, t2);
		}

		System.out.println(Math.min(count1, count2));
		out.close();

	}
}

import java.util.*;
import static java.lang.Math.*;

public class Elimination
{
    public static void main(String []av) {
        Scanner s = new Scanner(System.in);
        int c = s.nextInt();
        int d = s.nextInt();
        int n = s.nextInt();
        int m = s.nextInt();
        int k = s.nextInt();
        int need = n * m - k;

        // c * x * n + d * y >= need
        // (x + y) -> min
        int _min = 10000000;
        for (int x = 0; x < 10001; x++) {
            // d * y >= need - c * x * n
            int dy = max(need - c * x * n, 0);
            while (dy % d != 0)
                dy++;

            int y = dy / d;
            _min = min(_min, x + y);
        }
        System.out.println(_min);
    }
}

import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

import javax.security.auth.kerberos.KerberosKey;

import static java.lang.Math.*;

public class Main {

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	void init() throws FileNotFoundException {
		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	int gcd(int a, int b) {
		if (b == 0)
			return a;
		else
			return gcd(b, a % b);
	}

	int fib(int n) {
		if (n == 1)
			return 1;
		if (n == 2)
			return 2;
		else
			return fib(n - 1) + fib(n - 2);
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	public static void main(String[] args) {
		new Main().run();
		// Sworn to fight and die
	}

	public static void mergeSort(int[] a) {
		mergeSort(a, 0, a.length - 1);
	}

	private static void mergeSort(int[] a, int levtIndex, int rightIndex) {
		final int MAGIC_VALUE = 50;
		if (levtIndex < rightIndex) {
			if (rightIndex - levtIndex <= MAGIC_VALUE) {
				insertionSort(a, levtIndex, rightIndex);
			} else {
				int middleIndex = (levtIndex + rightIndex) / 2;
				mergeSort(a, levtIndex, middleIndex);
				mergeSort(a, middleIndex + 1, rightIndex);
				merge(a, levtIndex, middleIndex, rightIndex);
			}
		}
	}

	private static void merge(int[] a, int levtIndex, int middleIndex,
			int rightIndex) {
		int length1 = middleIndex - levtIndex + 1;
		int length2 = rightIndex - middleIndex;
		int[] levtArray = new int[length1];
		int[] rightArray = new int[length2];
		System.arraycopy(a, levtIndex, levtArray, 0, length1);
		System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
		for (int k = levtIndex, i = 0, j = 0; k <= rightIndex; k++) {
			if (i == length1) {
				a[k] = rightArray[j++];
			} else if (j == length2) {
				a[k] = levtArray[i++];
			} else {
				a[k] = levtArray[i] <= rightArray[j] ? levtArray[i++]
						: rightArray[j++];
			}
		}
	}

	private static void insertionSort(int[] a, int levtIndex, int rightIndex) {
		for (int i = levtIndex + 1; i <= rightIndex; i++) {
			int current = a[i];
			int j = i - 1;
			while (j >= levtIndex && a[j] > current) {
				a[j + 1] = a[j];
				j--;
			}
			a[j + 1] = current;
		}
	}

	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			init();
			solve();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Exception e) {
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	class LOL implements Comparable<LOL> {
		int x;
		int y;

		public LOL(int x, int y) {
			this.x = x;
			this.y = y;
		}

		@Override
		public int compareTo(LOL o) {

			//if (y == o.y)
			//	return (o.x - x);
			return x - o.x; // ---->
			// return o.x - x; // <----
			// return o.y-y;
		}

	}

	public int unusualSquare(int [][] a, int n) {
		int s = 0;
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				s += a[i][j]*a[j][i];
		return s % 2;
	}

	public void solve() throws IOException {
		int c = readInt();
		int d = readInt();
		int n = readInt();
		int m = readInt();
		int k = readInt();
		int s = 100000;
		int x = 0;
		int y = 0;
		for (int i = 0; i < 1000; i++)
			for (int j = 0; j < 1000; j++)
				if (n * i + j >= n*m - k)
					s = min(s, c*i + d*j);
		out.print(s);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/**
 * Created by Vadim_2 on 20.04.2014.
 */
public class A1 {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(reader.readLine());

        int c = Integer.parseInt(st.nextToken());
        int d = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(reader.readLine());

        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(reader.readLine());
        int k = Integer.parseInt(st.nextToken());
        if(k>=n*m) {
            System.out.println(0);
        } else
        if(d<=c/n) {
            System.out.println((n*m - k) * d);
        } else {
            System.out.println((n*m - k)/n*c + (((n*m - k) % n != 0) ? c: 0) );
        }
    }
}

/*******************************************************************
My love has gone away,
quietly after a hundered days.
This is what's she has always said she won't stay
for more than what she can repay.

I can still hear her say there
that I'm not hearing tender play
The day she let me kiss her was a display,
of love to those who she betray.

How can I put someone to the test,
when I thought I got the best.
Untill the taste of bitterness then I regret
but still that I won't detest,
the love I can't forget,
like someone who has left.

How can i leave someone for the rest
when i'm alone facing the best
Untill they take some try to reason i regret
But still that i won't detest
who i can never forget
like someone i once met ..
 ******************************************************************/
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.InputMismatchException;

public class TaskA_417 {
	public static void main(String[] args) {
		input();
		solve();
	}

	static void solve() {
		int res = 0;
		int count = 0;
		int max = m * n - k;
		while (count < max) {
			if (c > d * n
					|| ((max - count) / c < (max - count) && max - count < n)) {
				res += d;
				count++;
			} else {
				res += c;
				count += n;
			}
		}
		System.out.println(res);
	}

	/************************************************************************************/
	static int c;
	static int d;
	static int n;
	static int m;
	static int k;

	static void input() {
		c = nextInt();
		d = nextInt();
		n = nextInt();
		m = nextInt();
		k = nextInt();
	}

	/************************************************************************************/
	static InputStream is = System.in;
	static private byte[] buffer = new byte[1024];
	static private int lenbuf = 0, ptrbuf = 0;

	static private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = is.read(buffer);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return buffer[ptrbuf++];
	}

	static private boolean isSpace(int c) {
		return !(c >= 33 && c <= 126);
	}

	static private int read() {
		int b;
		while ((b = readByte()) != -1 && isSpace(b))
			;
		return b;
	}

	static private double nextDouble() {
		return Double.parseDouble(nextString());
	}

	static private char nextChar() {
		return (char) read();
	}

	static private String nextString() {
		int b = read();
		StringBuilder sb = new StringBuilder();
		while (!(isSpace(b))) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	static private char[] nextString(int n) {
		char[] buf = new char[n];
		int b = read(), p = 0;
		while (p < n && !(isSpace(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	static private int nextInt() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nextLong() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	static private int[] nextAi(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author DELL
 */
public class main{

    public static void main(String args[]) throws IOException {
        BufferedReader x = new BufferedReader(new InputStreamReader(System.in));
        String s = x.readLine();
        String s1[] = s.split(" ");
        int c = Integer.parseInt(s1[0]);
        int d = Integer.parseInt(s1[1]);
        s = x.readLine();
        String s2[] = s.split(" ");
        int n = Integer.parseInt(s2[0]);
        int m = Integer.parseInt(s2[1]);
        int k = Integer.parseInt(x.readLine());
        int total = n * m;
        int t = total - k;
        if (t <= 0) {
            System.out.println("0");
            return;
        }
        int res = 0;
        int a = 0;
        int b = 0;
        if (c <= d) {
            b = 0;
            a = t / n;
            if (t % n != 0) {
                a++;
            }
        } else {
            a = t / n;
            if (t % n != 0) {
                b = t % n;
            }
            if (d * b > c) {
                b = 0;
                a++;
            }
        }
        res = c * a + d * b;
        System.out.println(res);
    }
}

import java.util.Scanner;

public class MyClass {

    static int c, d, n, m, k, commonParty, must;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        c = sc.nextInt();
        d = sc.nextInt();
        n = sc.nextInt();
        m = sc.nextInt();
        k = sc.nextInt();
        commonParty = n * m;
        must = commonParty - k;

        if (must == 0) {
            System.out.println(0);
        } else {

            int algC = algC();
            int algD = algD();

            int algJoint = algC - c;
            int partyCMinusRound = (algJoint / c) * n;

            int i = (must - partyCMinusRound);
            while (i > 0) {
                i -= 1;
                algJoint += d;
            }

            System.out.println(min(algC, algD, algJoint));
        }

    }

    public static int algC() {
        int tempCommonParty = must;
        int sumTask = 0;
        while (tempCommonParty > 0) {
            tempCommonParty -= n;
            sumTask += c;
        }
        return sumTask;
    }

    public static int algD() {
        int tempCommonParty = must;
        int sumTask = 0;
        while (tempCommonParty > 0) {
            tempCommonParty -= 1;
            sumTask += d;
        }
        return sumTask;
    }

    public static int algFull() {
        //int tempCommonParty = must;
        int algC = algC();
        int algD = algD();

        int sumTask = algC - n;
        int partyCMinusRound = algC * (n - 1);

        int i = (must - partyCMinusRound);
        while (i > 0) {
            i -= 1;
            sumTask += d;
        }

        return min(algC, algD, sumTask);
    }

    public static int min(int... numbers) {
        int minNumber = Integer.MAX_VALUE;

        for (int number : numbers) {
            minNumber = (number < minNumber) ? number : minNumber;
        }

        return minNumber;
    }
}

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

public class RCCDiv2A {

	public static void main(String[] args) {

		int c = 0, d = 0, n = 0, m = 0, k = 0;
		Scanner in = new Scanner(System.in);

		c = in.nextInt();
		d = in.nextInt();
		n = in.nextInt();
		m = in.nextInt();
		k = in.nextInt();

		int fin = n*m, problem = 0;

		fin -= k;

		if (fin <= 0) {
			System.out.println(problem);
		}

		System.out.println(c*(int)(Math.ceil((double)fin/n)));
	}

}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt();
		int d = sc.nextInt();
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k = sc.nextInt();
		int min_que = Integer.MAX_VALUE;
		int total = n * m - k;
		int que_count = 0;
		if (total <= 0) {
			System.out.println(0);
			return;
		}
		for (int i = 1; i <= m; i++) {
			if (total - i * n > 0)
				que_count = i * c + (total - i * n) * d;
			else {
				que_count = i * c;
			}
			min_que = Math.min(que_count, min_que);
		}
		System.out.println(min_que);
	}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author rabeckiy
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int cm = n*m - k;
        if(cm == 0)
            out.println(0);
        else {
            int cc = (int)Math.floor(cm/n);
            int cd = (cm-cc*n) > 0?1:0;
            out.println(cc+cd);
        }
    }
}

import java.util.Scanner;

/**
 *
 * @author Hidayat
 */
public class Elimination {

    static int c, d, n;

    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        c = in.nextInt();
        d = in.nextInt();
        n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();

        int target = n * m - k;
        int result = target;

        System.out.println(result);

    }
}

import java.io.*;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;

public class CodeForces {

	public void solve() throws IOException {
		int c = nextInt();
		int d = nextInt();
		int n = nextInt();
		int m = nextInt();
		int k = nextInt();

		int res = Integer.MAX_VALUE;
		int nm = n * m - k;

		for (int i = 0; i <= nm / n + 1; i++) {
			for (int j = 0; j <= nm + 1; j++) {
				if(i*n+j>=nm){
					res = Math.min(res, i*c+j*d);
				}
			}
		}

		System.out.println(res);
	}

	public static void main(String[] args) {
		new CodeForces().run();
	}

	int NOD(int a, int b) {
		while (a != 0 && b != 0) {
			if (a >= b)
				a = a % b;
			else
				b = b % a;
		}
		return a + b;
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	boolean isOuterFile = false;

	public void run() {
		try {
			if (isOuterFile) {
				reader = new BufferedReader(new FileReader(
						"C:\\work\\javaprojects\\CodeForces\\SCC.txt"));
				// out = new PrintWriter(new BufferedWriter(new FileWriter(
				// "output.txt")));
				// out = new PrintWriter(System.out);
			} else {
				reader = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			tokenizer = null;

			// long time = System.currentTimeMillis();
			solve();
			// out.println(System.currentTimeMillis() - time);
			reader.close();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}

import java.util.*;
public class Elimination {
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int c = sc.nextInt(), d = sc.nextInt(), n = sc.nextInt(), m = sc.nextInt(), k = sc.nextInt();
		int min = n*m - k;
		int q = 0;
		while(min >= n){
			q += Math.min(c, n*d);
			min -= n;
		}
		q += Math.min(c, min*d);
		System.out.println(q);
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class elimination {
public static void main(String[] args) throws IOException {
	BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
	String p=bf.readLine();
	String []h=p.split(" ");
	int c=Integer.parseInt(h[0]);
	int d=Integer.parseInt(h[1]);
	 p=bf.readLine();
	 h=p.split(" ");
	int n=Integer.parseInt(h[0]);
	int m=Integer.parseInt(h[1]);
	int k=Integer.parseInt(bf.readLine());
	int sumPeople=(n*m)-k;
	int x=sumPeople*d;
	int y=0;
	int sum=0;
	while(sum<sumPeople)
	{
		sum+=n;
		y+=c;
	}
	if(x<y)
	{
		System.out.println(x);
	}
	else
	{
		System.out.println(y);
	}
}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class RCC_A {
    public static void main(String[] args) throws Exception {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] l = bf.readLine().split(" ");
        int c = Integer.parseInt(l[0]);
        int d = Integer.parseInt(l[1]);
        l = bf.readLine().split(" ");
        int n = Integer.parseInt(l[0]);
        int m = Integer.parseInt(l[1]);
        int k = Integer.parseInt(bf.readLine());
        int minUsed = Integer.MAX_VALUE;
        for (int main = 0; main <= 1000; main++) {
            for (int add = 0; add <= 1000; add++) {
                if ((main / c) * n + (add / d) + k >= n * m) {
                    minUsed = Math.min(minUsed, main + add);
                }
            }
        }
        System.out.println(minUsed);
    }
}

import java.util.Scanner;

public class Input {

    public static void main(String[] args) {

        int c,d,m,n,k;
        int winners, questions = 0, left;
        @SuppressWarnings("resource")
        Scanner in = new Scanner(System.in);

        c = in.nextInt();
        d = in.nextInt();
        n = in.nextInt();
        m = in.nextInt();
        k = in.nextInt();

        winners = m*n - k;
        if (winners == 0) {
            questions = 0;
        } else {
            float f = c/d;
            if (f < n) {
                questions = (int) (Math.floor(winners/n) * c);
                left = winners%n;
                if (left*d < c) questions += left*d;
                else questions += c;
            }
        }
        System.out.println((questions >= 0) ? questions : 0);

    }

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class A {
    public static void main(String[] args) throws IOException {
        BufferedReader input =
			new BufferedReader(new InputStreamReader(System.in));
		String[] cd = input.readLine().split(" ");
		String[] nm = input.readLine().split(" ");
		int k = Integer.parseInt(input.readLine());
		int c = Integer.parseInt(cd[0]);
		int d = Integer.parseInt(cd[1]);
		int n = Integer.parseInt(nm[0]);
		int m = Integer.parseInt(nm[1]);
		int s = n*m - k;
		int min = Integer.MAX_VALUE;
		for (int i = 0; i <= s/n + 1; i++) {
		    if (min > i + Math.max(s - i*n,0) * d)
		        min = i + Math.max(s - i*n,0) * d;
		}
		System.out.println(min);
    }
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {

    int[] dp;
    int c, d, n, m, k;

    public void solve(int testNumber, InputReader in, OutputWriter out) {
        c = in.readInt();
        d = in.readInt();
        n = in.readInt();
        m = in.readInt();
        k = in.readInt();
        int remaining = n * m - k;
        dp = new int[n * m];
        Arrays.fill(dp, -1);
        out.printLine(findMin(remaining));
    }

    int findMin(int remaining) {
        if (remaining <= 0) {
            return 0;
        }
        else if (dp[remaining] != -1) {
            return dp[remaining];
        }
        int res = findMin(remaining - 1) + d;
        res = Math.min(res, findMin(remaining - n) + c);
        return dp[n] = res;
    }
}

class InputReader {

    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 readInt() {
        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 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;
    }

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

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object...objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object...objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class elimination {
public static void main(String[] args) throws IOException {
	BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
	String p=bf.readLine();
	String []h=p.split(" ");
	int c=Integer.parseInt(h[0]);
	int d=Integer.parseInt(h[1]);
	 p=bf.readLine();
	 h=p.split(" ");
	int n=Integer.parseInt(h[0]);
	int m=Integer.parseInt(h[1]);
	int k=Integer.parseInt(bf.readLine());
	int sumPeople=(n*m)-k;
	int x=sumPeople*d;
	int y=0;
	int sum=0;
	int temp;
	while(sum<sumPeople)
	{
		temp=(sumPeople-sum)*d;
		if(temp<c)
		{
			y+=temp;
			break;
		}
		sum+=n;
		y+=c;
	}
	if(x<y)
	{
		System.out.println(x);
	}
	else
	{
		System.out.println(y);
	}
}
}

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

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf417a {

    public static void main(String[] args) throws IOException {
        int c = rni(), d = ni(), n = rni(), m = ni(), k = ri(), need = n * m - k;
        if (need <= 0) {
            prln(0);
        } else {
            prln(minof(need / n * c + need % n * m, (need / n + 1) * c, need * m));
        }
        close();
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random __rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IMAX ~= 2e9
    // LMAX ~= 9e18

    // constants
    static final int IBIG = 1000000007;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // math util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); int min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return min(x[0], x[1]); if(x.length == 3) return min(x[0], min(x[1], x[2])); long min = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] < min) min = x[i]; return min;}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); int max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {if(x.length == 1) return x[0]; if(x.length == 2) return max(x[0], x[1]); if(x.length == 3) return max(x[0], max(x[1], x[2])); long max = x[0]; for(int i = 1; i < x.length; ++i) if(x[i] > max) max = x[i]; return max;}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int fli(double d) {return (int)d;}
    static int cei(double d) {return (int)ceil(d);}
    static long fll(double d) {return (long)d;}
    static long cel(double d) {return (long)ceil(d);}
    static int gcf(int a, int b) {return b == 0 ? a : gcf(b, a % b);}
    static long gcf(long a, long b) {return b == 0 ? a : gcf(b, a % b);}
    static int lcm(int a, int b) {return a * b / gcf(a, b);}
    static long lcm(long a, long b) {return a * b / gcf(a, b);}
    static int randInt(int min, int max) {return __rand.nextInt(max - min + 1) + min;}
    static long hash(long x) {x += 0x9e3779b97f4a7c15L; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9L; x = (x ^ (x >> 27)) * 0x94d049bb133111ebL; return x ^ (x >> 31);}
    // array util
    static void reverse(int[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {int swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(long[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {long swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void reverse(char[] a) {for(int i = 0, n = a.length, half = n / 2; i < half; ++i) {char swap = a[i]; a[i] = a[n - i - 1]; a[n - i - 1] = swap;}}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void rsort(int[] a) {shuffle(a); sort(a);}
    static void rsort(long[] a) {shuffle(a); sort(a);}
    static int[] copy(int[] a) {int[] ans = new int[a.length]; for(int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    static long[] copy(long[] a) {long[] ans = new long[a.length]; for(int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    static char[] copy(char[] a) {char[] ans = new char[a.length]; for(int i = 0; i < a.length; ++i) ans[i] = a[i]; return ans;}
    // graph util
    static List<List<Integer>> g(int n) {List<List<Integer>> g = new ArrayList<>(); for(int i = 0; i < n; ++i) g.add(new ArrayList<>()); return g;}
    static List<Set<Integer>> sg(int n) {List<Set<Integer>> g = new ArrayList<>(); for(int i = 0; i < n; ++i) g.add(new HashSet<>()); return g;}
    static void c(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).add(v); g.get(v).add(u);}
    static void cto(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).add(v);}
    static void dc(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).remove(v); g.get(v).remove(u);}
    static void dcto(List<? extends Collection<Integer>> g, int u, int v) {g.get(u).remove(v);}
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static int[] riam1(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()) - 1; return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    static List<List<Integer>> rg(int n, int m) throws IOException {List<List<Integer>> g = g(n); for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1); return g;}
    static void rg(List<List<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1);}
    static List<List<Integer>> rdg(int n, int m) throws IOException {List<List<Integer>> g = g(n); for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1); return g;}
    static void rdg(List<List<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1);}
    static List<Set<Integer>> rsg(int n, int m) throws IOException {List<Set<Integer>> g = sg(n); for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1); return g;}
    static void rsg(List<Set<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) c(g, rni() - 1, ni() - 1);}
    static List<Set<Integer>> rdsg(int n, int m) throws IOException {List<Set<Integer>> g = sg(n); for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1); return g;}
    static void rdsg(List<Set<Integer>> g, int m) throws IOException {for(int i = 0; i < m; ++i) cto(g, rni() - 1, ni() - 1);}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); if(n >= 0) __out.println(iter.next()); else __out.println();}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}

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

public class CJ2 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String inp[] = br.readLine().split(" ");
		int c = Integer.parseInt(inp[0]);
		int d = Integer.parseInt(inp[1]);
		inp=br.readLine().split(" ");
		int n = Integer.parseInt(inp[0]);
		int m = Integer.parseInt(inp[1]);
		int k= Integer.parseInt(br.readLine());
		int minfinalists=n*m-k;
		int x=0; //rounds main, c problems
		int y=0; //rounds additional, d problems
		int ymax=minfinalists;
		int minscore=Integer.MAX_VALUE;
		for (int i=0;i<ymax+1;i++)
		{
			y=i;
			x=(int)Math.ceil((float)(minfinalists-y)/n);
			minscore=Math.min(x*c + y*d,  minscore);
		}
		System.out.println(minscore);
	}

}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author PrateekNischal
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Elimination solver = new Elimination();
		solver.solve(1, in, out);
		out.close();
	}
}

class Elimination {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int c = in.nextInt();
        int d = in.nextInt();
        int n = in.nextInt();
        int m = in.nextInt();
        int k = in.nextInt();
        int lim = n*m - k;
        int res = 0;
        while (lim > 0)
        {
            if (c <= n*d) {
                lim -= n;
                res += c;
            }
            else{
                lim -= n;
                res += n*d;
            }
        }
        out.println(res);
    }
}

class InputReader
{
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    public int bufferSize = 32768;
    public InputReader(InputStream stream)
    {
        reader = new BufferedReader(new InputStreamReader(stream), bufferSize);
        tokenizer = null;
    }

    public String next()
    {
        while (tokenizer == null || !tokenizer.hasMoreTokens()){
            try{
                tokenizer = new StringTokenizer(reader.readLine());
            }catch(IOException e){throw new RuntimeException(e);}
        }
        return tokenizer.nextToken();
    }

    public int nextInt(){
        return Integer.parseInt(next());
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Scanner;

public class A241 {

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int c = sc.nextInt();
        int d = sc.nextInt();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();

        int min = n*m;
        int need = 0;
        if(min>k){
            need = min-k;
        }else{
            System.out.println("0");
            System.exit(0);
        }
        if(need<n){
            if(d*need<c){
                System.out.println(d*need);
            }else{
                System.out.println(c);

            }
            System.exit(0);
        }
        int ans=0;
       // System.out.println("need = "+need);
        if(n*d<=c){
            //System.out.println("^^^^");
           // System.out.println(n*d);
            ans=d;
            //System.out.println("ans "+ans);
        }else {
            ans+=(need/n)*c;
            int rem = need%n;
            if(rem*d<c){
                ans+=rem*d;
            }else{
                ans+=c;
            }
        }

        System.out.println(ans);

    }

    public static void main(String[] args) throws IOException {
        new A241().solve();

    }
}