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.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.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.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 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.*;
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.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.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.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 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.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.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 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.*;
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.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.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.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.*;
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.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.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 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);
	}
}

/*
 * 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.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);
		}
	}

};

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.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();
	}

}

/**
 * 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.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.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.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.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.*;
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.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.*;

/**
 * @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.*;
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.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.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.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();
		}

	}

}

/* 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.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.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.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);

	}

}

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.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);
	}

}

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.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);
    }
}

/*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.*;
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));
    }
}

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.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.*;
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();
	}

}

/**
 * @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.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);

    }
}

/**
 * @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.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.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.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.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.*;
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 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.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 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();
  }
}

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.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.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.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();

    }
}