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

public class Main {
	int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int ans=a*x+b*y;
		int n=1;
		while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		}
		out.println(ans);
		out.close();
	}

	// ----------------------------------------------------------
	static int l_min(int[] a) {
		Arrays.sort(a);
		return a[0];
	}

	static int l_max(int[] a) {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	}

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

	}

	public static PrintWriter out;

}

class UnionFind {
	int parent[];
	int rank[];
	int size[];

	UnionFind(int n) {
		parent = new int[n];
		rank = new int[n];
		size = new int[n];
		for (int i = 0; i < n; i++) {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		}
	}

	void union(int x, int y) {
		int xRoot = find(x);
		int yRoot = find(y);

		if (xRoot != yRoot) {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		}

	}

	int find(int x) {
		if (parent[x] == x) {
			return x;
		} else {
			return find(parent[x]);
		}

	}

	boolean same(int x, int y) {
		return find(x) == find(y);
	}

}

class FastScanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		return hasNextByte();
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}

	public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
} import java.io.*; io.* java import java.util.*; util.* java import java.lang.*; lang.* java public class Main {
	int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int ans=a*x+b*y;
		int n=1;
		while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		}
		out.println(ans);
		out.close();
	}

	// ----------------------------------------------------------
	static int l_min(int[] a) {
		Arrays.sort(a);
		return a[0];
	}

	static int l_max(int[] a) {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	}

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

	}

	public static PrintWriter out;

} Main int mod = 1000000007; mod 1000000007 public static PrintWriter out; out public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int ans=a*x+b*y;
		int n=1;
		while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		}
		out.println(ans);
		out.close();
	} main {
		FastScanner sc = new FastScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int ans=a*x+b*y;
		int n=1;
		while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		}
		out.println(ans);
		out.close();
	} FastScanner sc = new FastScanner(); sc new FastScanner() out = new PrintWriter(new BufferedOutputStream(System.out)) out new PrintWriter(new BufferedOutputStream(System.out)) int a=sc.nextInt(); a sc.nextInt() sc.nextInt sc int b=sc.nextInt(); b sc.nextInt() sc.nextInt sc int c=sc.nextInt(); c sc.nextInt() sc.nextInt sc int x=sc.nextInt(); x sc.nextInt() sc.nextInt sc int y=sc.nextInt(); y sc.nextInt() sc.nextInt sc int ans=a*x+b*y; ans a*x+b*y a*x a x b*y b y int n=1; n 1 while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		} a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c a*Math.max(0,(x-n)) a Math.max(0,(x-n)) Math.max Math 0 (x-n) x n b*Math.max((y-n),0) b Math.max((y-n),0) Math.max Math (y-n) y n 0 2*n*c 2*n*c 2 n c ans {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		} ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c ans a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c a*Math.max(0,(x-n)) a Math.max(0,(x-n)) Math.max Math 0 (x-n) x n b*Math.max((y-n),0) b Math.max((y-n),0) Math.max Math (y-n) y n 0 2*n*c 2*n*c 2 n c n++ n out.println(ans) out.println out ans out.close() out.close out String[] args args // ----------------------------------------------------------
	static int l_min(int[] a) {
		Arrays.sort(a);
		return a[0];
	} l_min {
		Arrays.sort(a);
		return a[0];
	} Arrays.sort(a) Arrays.sort Arrays a return a[0]; a[0] a 0 int[] a a static int l_max(int[] a) {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	} l_max {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	} int l = a.length; l a.length a a.length Arrays.sort(a) Arrays.sort Arrays a return a[l - 1]; a[l - 1] a l - 1 l 1 int[] a a static int gcd(int a, int b) {
		if (a == 0) {
			return b;
		}
		return gcd(b % a, a);

	} gcd {
		if (a == 0) {
			return b;
		}
		return gcd(b % a, a);

	} if (a == 0) {
			return b;
		} a == 0 a 0 {
			return b;
		} return b; b return gcd(b % a, a); gcd(b % a, a) gcd b % a b a a int a a int b b class UnionFind {
	int parent[];
	int rank[];
	int size[];

	UnionFind(int n) {
		parent = new int[n];
		rank = new int[n];
		size = new int[n];
		for (int i = 0; i < n; i++) {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		}
	}

	void union(int x, int y) {
		int xRoot = find(x);
		int yRoot = find(y);

		if (xRoot != yRoot) {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		}

	}

	int find(int x) {
		if (parent[x] == x) {
			return x;
		} else {
			return find(parent[x]);
		}

	}

	boolean same(int x, int y) {
		return find(x) == find(y);
	}

} UnionFind int parent[]; parent int rank[]; rank int size[]; size UnionFind(int n) {
		parent = new int[n];
		rank = new int[n];
		size = new int[n];
		for (int i = 0; i < n; i++) {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		}
	} UnionFind {
		parent = new int[n];
		rank = new int[n];
		size = new int[n];
		for (int i = 0; i < n; i++) {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		}
	} parent = new int[n] parent new int[n] n rank = new int[n] rank new int[n] n size = new int[n] size new int[n] n for (int i = 0; i < n; i++) {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		} int i = 0; int i = 0; i 0 i < n i n i++ i++ i {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		} {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		} parent[i] = i parent[i] parent i i rank[i] = 0 rank[i] rank i 0 size[i] = 1 size[i] size i 1 int n n void union(int x, int y) {
		int xRoot = find(x);
		int yRoot = find(y);

		if (xRoot != yRoot) {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		}

	} union {
		int xRoot = find(x);
		int yRoot = find(y);

		if (xRoot != yRoot) {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		}

	} int xRoot = find(x); xRoot find(x) find x int yRoot = find(y); yRoot find(y) find y if (xRoot != yRoot) {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		} xRoot != yRoot xRoot yRoot {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		} if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			} rank[xRoot] > rank[yRoot] rank[xRoot] rank xRoot rank[yRoot] rank yRoot {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} parent[yRoot] = xRoot parent[yRoot] parent yRoot xRoot size[xRoot] += size[yRoot] size[xRoot] size xRoot size[yRoot] size yRoot if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			} rank[xRoot] < rank[yRoot] rank[xRoot] rank xRoot rank[yRoot] rank yRoot {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} parent[xRoot] = yRoot parent[xRoot] parent xRoot yRoot size[yRoot] += size[xRoot] size[yRoot] size yRoot size[xRoot] size xRoot {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			} parent[yRoot] = xRoot parent[yRoot] parent yRoot xRoot rank[xRoot]++ rank[xRoot] rank xRoot size[xRoot] += size[yRoot] size[xRoot] size xRoot size[yRoot] size yRoot int x x int y y int find(int x) {
		if (parent[x] == x) {
			return x;
		} else {
			return find(parent[x]);
		}

	} find {
		if (parent[x] == x) {
			return x;
		} else {
			return find(parent[x]);
		}

	} if (parent[x] == x) {
			return x;
		} else {
			return find(parent[x]);
		} parent[x] == x parent[x] parent x x {
			return x;
		} return x; x {
			return find(parent[x]);
		} return find(parent[x]); find(parent[x]) find parent[x] parent x int x x boolean same(int x, int y) {
		return find(x) == find(y);
	} same {
		return find(x) == find(y);
	} return find(x) == find(y); find(x) == find(y) find(x) find x find(y) find y int x x int y y class FastScanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		return hasNextByte();
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}

	public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}
} FastScanner private final InputStream in = System.in; in System.in System System.in private final byte[] buffer = new byte[1024]; buffer new byte[1024] 1024 private int ptr = 0; ptr 0 private int buflen = 0; buflen 0 private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	} hasNextByte {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	} if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		} ptr < buflen ptr buflen {
			return true;
		} return true; true {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		} ptr = 0 ptr 0 try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			} IOException e {
				e.printStackTrace();
			} e.printStackTrace() e.printStackTrace e {
				buflen = in.read(buffer);
			} buflen = in.read(buffer) buflen in.read(buffer) in.read in buffer if (buflen <= 0) {
				return false;
			} buflen <= 0 buflen 0 {
				return false;
			} return false; false return true; true private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	} readByte {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	} if (hasNextByte())
			return buffer[ptr++];
		else
			return -1; hasNextByte() hasNextByte return buffer[ptr++]; buffer[ptr++] buffer ptr++ ptr return -1; -1 1 private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	} isPrintableChar {
		return 33 <= c && c <= 126;
	} return 33 <= c && c <= 126; 33 <= c && c <= 126 33 <= c 33 c c <= 126 c 126 int c c public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		return hasNextByte();
	} hasNext {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		return hasNextByte();
	} while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++; hasNextByte() && !isPrintableChar(buffer[ptr]) hasNextByte() hasNextByte !isPrintableChar(buffer[ptr]) isPrintableChar(buffer[ptr]) isPrintableChar buffer[ptr] buffer ptr ptr++ ptr return hasNextByte(); hasNextByte() hasNextByte public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	} next {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	} if (!hasNext())
			throw new NoSuchElementException(); !hasNext() hasNext() hasNext throw new NoSuchElementException(); new NoSuchElementException() StringBuilder sb = new StringBuilder(); sb new StringBuilder() int b = readByte(); b readByte() readByte while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		} isPrintableChar(b) isPrintableChar b {
			sb.appendCodePoint(b);
			b = readByte();
		} sb.appendCodePoint(b) sb.appendCodePoint sb b b = readByte() b readByte() readByte return sb.toString(); sb.toString() sb.toString sb public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	} nextLong {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	} if (!hasNext())
			throw new NoSuchElementException(); !hasNext() hasNext() hasNext throw new NoSuchElementException(); new NoSuchElementException() long n = 0; n 0 boolean minus = false; minus false int b = readByte(); b readByte() readByte if (b == '-') {
			minus = true;
			b = readByte();
		} b == '-' b '-' {
			minus = true;
			b = readByte();
		} minus = true minus true b = readByte() b readByte() readByte if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		} b < '0' || '9' < b b < '0' b '0' '9' < b '9' b {
			throw new NumberFormatException();
		} throw new NumberFormatException(); new NumberFormatException() while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		} true {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		} if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			} '0' <= b && b <= '9' '0' <= b '0' b b <= '9' b '9' {
				n *= 10;
				n += b - '0';
			} n *= 10 n 10 n += b - '0' n b - '0' b '0' if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			} b == -1 || !isPrintableChar(b) b == -1 b -1 1 !isPrintableChar(b) isPrintableChar(b) isPrintableChar b {
				return minus ? -n : n;
			} return minus ? -n : n; minus ? -n : n minus -n n n {
				throw new NumberFormatException();
			} throw new NumberFormatException(); new NumberFormatException() b = readByte() b readByte() readByte public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	} nextInt {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	} long nl = nextLong(); nl nextLong() nextLong if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException(); nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE nl < Integer.MIN_VALUE nl Integer.MIN_VALUE Integer Integer.MIN_VALUE nl > Integer.MAX_VALUE nl Integer.MAX_VALUE Integer Integer.MAX_VALUE throw new NumberFormatException(); new NumberFormatException() return (int) nl; (int) nl public double nextDouble() {
		return Double.parseDouble(next());
	} nextDouble {
		return Double.parseDouble(next());
	} return Double.parseDouble(next()); Double.parseDouble(next()) Double.parseDouble Double next() next public class Main {
	int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int ans=a*x+b*y;
		int n=1;
		while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		}
		out.println(ans);
		out.close();
	}

	// ----------------------------------------------------------
	static int l_min(int[] a) {
		Arrays.sort(a);
		return a[0];
	}

	static int l_max(int[] a) {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	}

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

	}

	public static PrintWriter out;

} public class Main {
	int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int ans=a*x+b*y;
		int n=1;
		while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		}
		out.println(ans);
		out.close();
	}

	// ----------------------------------------------------------
	static int l_min(int[] a) {
		Arrays.sort(a);
		return a[0];
	}

	static int l_max(int[] a) {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	}

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

	}

	public static PrintWriter out;

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

public class Main {
	int mod = 1000000007;

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		int a=sc.nextInt();
		int b=sc.nextInt();
		int c=sc.nextInt();
		int x=sc.nextInt();
		int y=sc.nextInt();
		int ans=a*x+b*y;
		int n=1;
		while(a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c<=ans) {
			ans=a*Math.max(0,(x-n))+b*Math.max((y-n),0)+2*n*c;
			n++;
		}
		out.println(ans);
		out.close();
	}

	// ----------------------------------------------------------
	static int l_min(int[] a) {
		Arrays.sort(a);
		return a[0];
	}

	static int l_max(int[] a) {
		int l = a.length;
		Arrays.sort(a);
		return a[l - 1];
	}

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

	}

	public static PrintWriter out;

}

class UnionFind {
	int parent[];
	int rank[];
	int size[];

	UnionFind(int n) {
		parent = new int[n];
		rank = new int[n];
		size = new int[n];
		for (int i = 0; i < n; i++) {
			parent[i] = i;
			rank[i] = 0;
			size[i] = 1;
		}
	}

	void union(int x, int y) {
		int xRoot = find(x);
		int yRoot = find(y);

		if (xRoot != yRoot) {

			if (rank[xRoot] > rank[yRoot]) {
				parent[yRoot] = xRoot;
				size[xRoot] += size[yRoot];

			} else if (rank[xRoot] < rank[yRoot]) {
				parent[xRoot] = yRoot;
				size[yRoot] += size[xRoot];

			} else {
				parent[yRoot] = xRoot;
				rank[xRoot]++;
				size[xRoot] += size[yRoot];
			}
		}

	}

	int find(int x) {
		if (parent[x] == x) {
			return x;
		} else {
			return find(parent[x]);
		}

	}

	boolean same(int x, int y) {
		return find(x) == find(y);
	}

}

class FastScanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	public boolean hasNext() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
		return hasNextByte();
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}

	public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
			throw new NumberFormatException();
		return (int) nl;
	}

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