You've got a string a_1, a_2, ..., a_n, consisting of zeros and ones.

Let's call a sequence of consecutive elements a_i, a_{i + 1}, …, a_j (1≤ i≤ j≤ n) a substring of string a. 

You can apply the following operations any number of times:

  * Choose some substring of string a (for example, you can choose entire string) and reverse it, paying x coins for it (for example, «0101101» → «0111001»); 
  * Choose some substring of string a (for example, you can choose entire string or just one symbol) and replace each symbol to the opposite one (zeros are replaced by ones, and ones — by zeros), paying y coins for it (for example, «0101101» → «0110001»). 



You can apply these operations in any order. It is allowed to apply the operations multiple times to the same substring.

What is the minimum number of coins you need to spend to get a string consisting only of ones?

Input

The first line of input contains integers n, x and y (1 ≤ n ≤ 300 000, 0 ≤ x, y ≤ 10^9) — length of the string, cost of the first operation (substring reverse) and cost of the second operation (inverting all elements of substring).

The second line contains the string a of length n, consisting of zeros and ones.

Output

Print a single integer — the minimum total cost of operations you need to spend to get a string consisting only of ones. Print 0, if you do not need to perform any operations.

Examples

Input

5 1 10
01000


Output

11


Input

5 10 1
01000


Output

2


Input

7 2 3
1111111


Output

0

Note

In the first sample, at first you need to reverse substring [1 ... 2], and then you need to invert substring [2 ... 5]. 

Then the string was changed as follows:

«01000» → «10000» → «11111».

The total cost of operations is 1 + 10 = 11.

In the second sample, at first you need to invert substring [1 ... 1], and then you need to invert substring [3 ... 5]. 

Then the string was changed as follows:

«01000» → «11000» → «11111».

The overall cost is 1 + 1 = 2.

In the third example, string already consists only of ones, so the answer is 0.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeSet;
/*
 * Java Input / Output Class using Buffered/ Input Straem
 * Created by @neelbhallabos
 * File Created at: Jul 1, 2018
 */
public class CF998C {
	public static BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
	public static StringTokenizer st;
	public static PrintWriter pw = new PrintWriter(System.out);
	final static boolean debugmode = true;
	public static int k = 7; // for 10^9 + k mods.
	public static long STMOD = 1000000000 + k; // 10^9 + k

	public static void main(String[] args) throws IOException {
		int sizeof = getInt();
		int revcost = getInt();
		int flipop = getInt();
		// lets break up into segments and try manipulating them.
		int seg = 0;
		String r = getLine();
		if(r.charAt(0)-'0' == 1) {
			seg = -1;
		}
		for(int i = 1; i < r.length();i++) {
			if(r.charAt(i) != r.charAt(i-1)) {
				seg++;
			}
		}
		int[] item = new int[seg+1];
		int cindex = 0;
		if(r.charAt(0)-'0' == 1) {
			cindex = -1;
		}
		for(int i = 0; i < r.length();i++) {
			if(i != 0 && r.charAt(i) != r.charAt(i-1)) {
				cindex++;
			}
			if(cindex >= 0) {
				item[cindex]++;
			}
		}
		//System.out.println(Arrays.toString(item));
		// at any point you can either reverse it or free it.
		if(item.length == 3) {
			submit(Math.min(revcost + flipop, 2*flipop),true);
			return;
		}
		else if(item.length == 2) {
			submit(flipop,true);
			return;
		}
		if(item.length == 1) {
			submit(flipop,true);
			return;
		}
		else if(item.length == 0) {
			submit(0,true);
			return;
		}
		double blacklength = item[0];
		double whitelength = item[1];
		double blacklength2 = item[2];
		//either we flip this whole thing, or we reverse it.
		long ccost= 0;
		for(int i = 2; i < item.length-2;i++) {
			
			if((blacklength+whitelength+blacklength2)/(2*flipop) > (whitelength+blacklength+blacklength2) /(revcost+flipop)) {
				//System.out.println("flip");
				ccost += flipop;
				blacklength = item[i]+whitelength;
				if(item.length > i+2) {
					whitelength = item[i+1];
					blacklength2 = item[i+2];
					i++;
					
				}
				else {
					ccost += flipop;
					//System.out.println("defaulted");
					submit(ccost,true);
					return;
				}
			}
			else {
				blacklength += item[i];
				//System.out.println("reverseed");
				ccost += revcost;

				if(item.length > i+2) {
					whitelength = item[i+1];
					blacklength2 = item[i+2];
					i++;
				}
				else {
					ccost += flipop;
					//System.out.println("defaulted2");
					submit(ccost,true);
					return;
				}
			}
			
		}
		//System.out.println(blacklength + " "+whitelength+"  "+blacklength2);
		if(blacklength > 0) {
			submit(ccost+Math.min(revcost + flipop, 2*flipop),true);
		}
		
		
		
		
		
	}

	public static void setInputFile(String fn) throws IOException {
		sc = new BufferedReader(new FileReader(fn));
	}

	public static void setOutputFile(String fn) throws IOException {
		pw = new PrintWriter(new BufferedWriter(new FileWriter(fn)));
	}

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

	public static double log(int k, int v) {
		return Math.log(k) / Math.log(v);
	}

	public static long longpower(int a, int b) {
		long[] vals = new long[(int) (log(b, 2) + 2)];
		vals[0] = a;
		vals[1] = a * a;
		for (int i = 1; i < vals.length; i++) {
			vals[i] = vals[i - 1] * vals[i - 1];
		}
		long ans = 1;
		int cindex = 0;
		while (b != 0) {
			if (b % 2 == 1) {
				ans *= vals[cindex];
			}
			cindex += 1;
			b /= 2;
		}
		return ans;

	}

	public static void debug(String toPrint) {
		if (!debugmode) {
			return;
		}
		pw.println("[DEBUG]: " + toPrint);
	}

	public static void submit(int[] k, boolean close) {
		pw.println(Arrays.toString(k));
		if (close) {
			pw.close();
		}
	}

	public static void submit(int p, boolean close) {
		pw.println(Integer.toString(p));
		if (close) {
			pw.close();
		}
	}

	public static void submit(String k, boolean close) {
		pw.println(k);
		if (close) {
			pw.close();
		}
	}

	public static void submit(double u, boolean close) {
		pw.println(Double.toString(u));
		if (close) {
			pw.close();
		}
	}

	public static void submit(long lng, boolean close) {
		pw.println(Long.toString(lng));
		if (close) {
			pw.close();
		}

	}

	public static void submit() {
		pw.close();
	}

	public static int getInt() throws IOException {
		if (st != null && st.hasMoreTokens()) {
			return Integer.parseInt(st.nextToken());
		}
		st = new StringTokenizer(sc.readLine());
		return Integer.parseInt(st.nextToken());
	}

	public static long getLong() throws IOException {
		if (st != null && st.hasMoreTokens()) {
			return Long.parseLong(st.nextToken());
		}
		st = new StringTokenizer(sc.readLine());
		return Long.parseLong(st.nextToken());
	}

	public static double getDouble() throws IOException {
		if (st != null && st.hasMoreTokens()) {
			return Double.parseDouble(st.nextToken());
		}
		st = new StringTokenizer(sc.readLine());
		return Double.parseDouble(st.nextToken());
	}

	public static String getString() throws IOException {
		if (st != null && st.hasMoreTokens()) {
			return st.nextToken();
		}
		st = new StringTokenizer(sc.readLine());
		return st.nextToken();
	}

	public static String getLine() throws IOException {
		return sc.readLine();
	}

	public static int[][] readMatrix(int lines, int cols) throws IOException {
		int[][] matrr = new int[lines][cols];
		for (int i = 0; i < lines; i++) {
			for (int j = 0; j < cols; j++) {
				matrr[i][j] = getInt();
			}
		}
		return matrr;
	}

	public static int[] readArray(int lines) throws IOException {
		int[] ar = new int[lines];
		for (int i = 0; i < lines; i++)
			ar[i] = getInt();
		return ar;
	}

}
