Vasya's telephone contains n photos. Photo number 1 is currently opened on the phone. It is allowed to move left and right to the adjacent photo by swiping finger over the screen. If you swipe left from the first photo, you reach photo n. Similarly, by swiping right from the last photo you reach photo 1. It takes a seconds to swipe from photo to adjacent.

For each photo it is known which orientation is intended for it — horizontal or vertical. Phone is in the vertical orientation and can't be rotated. It takes b second to change orientation of the photo.

Vasya has T seconds to watch photos. He want to watch as many photos as possible. If Vasya opens the photo for the first time, he spends 1 second to notice all details in it. If photo is in the wrong orientation, he spends b seconds on rotating it before watching it. If Vasya has already opened the photo, he just skips it (so he doesn't spend any time for watching it or for changing its orientation). It is not allowed to skip unseen photos.

Help Vasya find the maximum number of photos he is able to watch during T seconds.

Input

The first line of the input contains 4 integers n, a, b, T (1 ≤ n ≤ 5·105, 1 ≤ a, b ≤ 1000, 1 ≤ T ≤ 109) — the number of photos, time to move from a photo to adjacent, time to change orientation of a photo and time Vasya can spend for watching photo.

Second line of the input contains a string of length n containing symbols 'w' and 'h'. 

If the i-th position of a string contains 'w', then the photo i should be seen in the horizontal orientation.

If the i-th position of a string contains 'h', then the photo i should be seen in vertical orientation.

Output

Output the only integer, the maximum number of photos Vasya is able to watch during those T seconds.

Examples

Input

4 2 3 10
wwhw


Output

2


Input

5 2 4 13
hhwhh


Output

4


Input

5 2 4 1000
hhwhh


Output

5


Input

3 1 100 10
whw


Output

0

Note

In the first sample test you can rotate the first photo (3 seconds), watch the first photo (1 seconds), move left (2 second), rotate fourth photo (3 seconds), watch fourth photo (1 second). The whole process takes exactly 10 seconds.

Note that in the last sample test the time is not enough even to watch the first photo, also you can't skip it.

//package cf;


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

public class D {

    public static void main(String[] args) {
        DIO io = new DIO();
        try {
            Dsolver solver = new Dsolver(io);
        } finally {
            io.close();
        }
    }

}

class Dsolver {

    public Dsolver(DIO io) {
        io.println(solve(io));
    }
    public int solve(DIO io) {
        int n = io.nextInt();
        int a = io.nextInt();
        int b = io.nextInt();
        int T = io.nextInt();
        String pix = io.next();
        
        int firstPicTimeSpent = 1;
        if (pix.charAt(0) == 'w') firstPicTimeSpent += b;
        if (firstPicTimeSpent > T) return 0;
        
        // always swipe right
        int picIndex = 1;
        int timeSpent = 0;
        int[] rightSwipe = new int[n];
        while (picIndex < n) {
            int timeToSeeNextPic = 1 + a;
            if (pix.charAt(picIndex) == 'w') timeToSeeNextPic += b;
            if ((long) timeSpent + timeToSeeNextPic + firstPicTimeSpent > T) break;
            timeSpent += timeToSeeNextPic;
            rightSwipe[picIndex] = timeSpent;
            picIndex++;
        }
        if (picIndex == n) return n;
        int atMostRight = picIndex-1;
        
        //System.out.println("ROUTE1 " + (1+atMostRight));
        
        
        // always swipe left
        picIndex = n-1;
        timeSpent = 0;
        int[] leftSwipe = new int[n+1];
        while (picIndex > 0) {
            int timeToSeeNextPic = 1 + a;
            if (pix.charAt(picIndex) == 'w') timeToSeeNextPic += b;
            if ((long) timeSpent + timeToSeeNextPic + firstPicTimeSpent > T) break;
            timeSpent += timeToSeeNextPic;
            leftSwipe[picIndex] = timeSpent;
            picIndex--;
        }
        picIndex++; // we went too far, correction
        
        
        int routeValue = (1 + n - picIndex);
        
        //System.out.println("ROUTE " + routeValue);
        
        int bestRouteValue = routeValue;
        long remainingTime = T - firstPicTimeSpent - timeSpent; // remaining time after swiping left as long as posisble
        int maxLeftPhoto = picIndex;
        int currentPhoto = picIndex;
        while (currentPhoto < n) {
            currentPhoto++;
            remainingTime -= a;
            if (remainingTime < 0) {
                maxLeftPhoto++;
                routeValue--;
                remainingTime += leftSwipe[maxLeftPhoto-1] - leftSwipe[maxLeftPhoto];
                remainingTime += a; // we dont have to expend this step to move back
            }
        }
        currentPhoto = 0; // correct index: currentPhoto was nominally at n, while largest photo index was n-1
        

        while (currentPhoto <= atMostRight) {
            int costToIncrementCurrent = rightSwipe[currentPhoto+1] - rightSwipe[currentPhoto];
            if (costToIncrementCurrent <= 0) break; // impossible to advance that far right
            if (remainingTime >= costToIncrementCurrent) {
                currentPhoto++;
                remainingTime -= costToIncrementCurrent;
                routeValue++;
                bestRouteValue = Math.max(routeValue, bestRouteValue);
            } else {
                maxLeftPhoto++;
                if (maxLeftPhoto >= n) break;
                routeValue--;
                remainingTime += leftSwipe[maxLeftPhoto-1] - leftSwipe[maxLeftPhoto];
                remainingTime += a; // we dont have to expend this step to move back
            }
        }
        
        //System.out.println("ROXX " + bestRouteValue);
        
        bestRouteValue = Math.max(bestRouteValue, reverseShit(atMostRight, rightSwipe, leftSwipe, firstPicTimeSpent, T, a, n));
        
        return bestRouteValue;
    }
    
    public int reverseShit(int currentPhoto, int[] rightSwipe, int[] leftSwipe, int firstPicTimeSpent, int T, int a, int n) {
        int routeValue = (1 + currentPhoto);
        int bestRouteValue = routeValue;
        int timeSpent = rightSwipe[currentPhoto];
        long remainingTime = T - firstPicTimeSpent - timeSpent;
        int maxRightPhoto = currentPhoto;
        while (currentPhoto > 0) {
            currentPhoto--;
            remainingTime -= a;
            if (remainingTime < 0) {
                maxRightPhoto--;
                routeValue--;
                remainingTime += rightSwipe[maxRightPhoto+1] - rightSwipe[maxRightPhoto];
                remainingTime += a; // we dont have to expend this step to move back
            }
        }
        currentPhoto = n;
        
        while (currentPhoto > 0) {
            int costToIncrementCurrent = leftSwipe[currentPhoto-1] - leftSwipe[currentPhoto];
            if (costToIncrementCurrent <= 0) break; // impossible to advance that far right
            if (remainingTime >= costToIncrementCurrent) {
                currentPhoto--;
                remainingTime -= costToIncrementCurrent;
                routeValue++;
                bestRouteValue = Math.max(routeValue, bestRouteValue);
            } else {
                maxRightPhoto--;
                if (maxRightPhoto < 1) break;
                routeValue--;
                remainingTime += rightSwipe[maxRightPhoto+1] - rightSwipe[maxRightPhoto];
                remainingTime += a; // we dont have to expend this step to move back
            }
        }
        return bestRouteValue;
    }
    
}

class DIO extends PrintWriter {
    private InputStreamReader r;
    private static final int BUFSIZE = 1 << 15;
    private char[] buf;
    private int bufc;
    private int bufi;
    private StringBuilder sb;

    public DIO() {
            super(new BufferedOutputStream(System.out));
            r = new InputStreamReader(System.in);

            buf = new char[BUFSIZE];
            bufc = 0;
            bufi = 0;
            sb = new StringBuilder();
    }

    private void fillBuf() throws IOException {
            bufi = 0;
            bufc = 0;
            while(bufc == 0) {
                    bufc = r.read(buf, 0, BUFSIZE);
                    if(bufc == -1) {
                            bufc = 0;
                            return;
                    }
            }
    }

    private boolean pumpBuf() throws IOException {
            if(bufi == bufc) {
                    fillBuf();
            }
            return bufc != 0;
    }

    private boolean isDelimiter(char c) {
            return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
    }

    private void eatDelimiters() throws IOException {
            while(true) {
                    if(bufi == bufc) {
                            fillBuf();
                            if(bufc == 0) throw new RuntimeException("IO: Out of input.");
                    }

                    if(!isDelimiter(buf[bufi])) break;
                    ++bufi;
            }
    }

    public String next() {
            try {
                    sb.setLength(0);

                    eatDelimiters();
                    int start = bufi;

                    while(true) {
                            if(bufi == bufc) {
                                    sb.append(buf, start, bufi - start);
                                    fillBuf();
                                    start = 0;
                                    if(bufc == 0) break;
                            }

                            if(isDelimiter(buf[bufi])) break;
                            ++bufi;
                    }

                    sb.append(buf, start, bufi - start);

                    return sb.toString();
            } catch(IOException e) {
                    throw new RuntimeException("IO.next: Caught IOException.");
            }
    }

    public int nextInt() {
            try {
                    int ret = 0;

                    eatDelimiters();

                    boolean positive = true;
                    if(buf[bufi] == '-') {
                            ++bufi;
                            if(!pumpBuf()) throw new RuntimeException("IO.nextInt: Invalid int.");
                            positive = false;
                    }

                    boolean first = true;
                    while(true) {
                            if(!pumpBuf()) break;
                            if(isDelimiter(buf[bufi])) {
                                    if(first) throw new RuntimeException("IO.nextInt: Invalid int.");
                                    break;
                            }
                            first = false;

                            if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                                    if(ret < -214748364) throw new RuntimeException("IO.nextInt: Invalid int.");
                                    ret *= 10;
                                    ret -= (int)(buf[bufi] - '0');
                                    if(ret > 0) throw new RuntimeException("IO.nextInt: Invalid int.");
                            } else {
                                    throw new RuntimeException("IO.nextInt: Invalid int.");
                            }

                            ++bufi;
                    }

                    if(positive) {
                            if(ret == -2147483648) throw new RuntimeException("IO.nextInt: Invalid int.");
                            ret = -ret;
                    }

                    return ret;
            } catch(IOException e) {
                    throw new RuntimeException("IO.nextInt: Caught IOException.");
            }
    }

    public long nextLong() {
            try {
                    long ret = 0;

                    eatDelimiters();

                    boolean positive = true;
                    if(buf[bufi] == '-') {
                            ++bufi;
                            if(!pumpBuf()) throw new RuntimeException("IO.nextLong: Invalid long.");
                            positive = false;
                    }

                    boolean first = true;
                    while(true) {
                            if(!pumpBuf()) break;
                            if(isDelimiter(buf[bufi])) {
                                    if(first) throw new RuntimeException("IO.nextLong: Invalid long.");
                                    break;
                            }
                            first = false;

                            if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                                    if(ret < -922337203685477580L) throw new RuntimeException("IO.nextLong: Invalid long.");
                                    ret *= 10;
                                    ret -= (long)(buf[bufi] - '0');
                                    if(ret > 0) throw new RuntimeException("IO.nextLong: Invalid long.");
                            } else {
                                    throw new RuntimeException("IO.nextLong: Invalid long.");
                            }

                            ++bufi;
                    }

                    if(positive) {
                            if(ret == -9223372036854775808L) throw new RuntimeException("IO.nextLong: Invalid long.");
                            ret = -ret;
                    }

                    return ret;
            } catch(IOException e) {
                    throw new RuntimeException("IO.nextLong: Caught IOException.");
            }
    }

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

}