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

}