 import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;



    public class Main {
    	
    	class Record{
    		public int parent;
    		public int child;
    		public Record( int p,int c){
    			parent=p;
    			child=c;
    		}
    	}
       public interface SpaceCharFilter {
           public boolean isSpaceChar(int ch);
           }
       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 long readLong() {
               int c = read();
               while (isSpaceChar(c))
                   c = read();
               int sgn = 1;
               if (c == '-') {
                   sgn = -1;
                   c = read();
               }
               long 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 String readString() {
               int c = read();
               while (isSpaceChar(c))
                   c = read();
               StringBuilder res = new StringBuilder();
               do {
                   res.appendCodePoint(c);
                   c = read();
               } while (!isSpaceChar(c));
               return res.toString();
           }
           public boolean isSpaceChar(int c) {
               if (filter != null)
                   return filter.isSpaceChar(c);
               return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
           }
           public String next() {
               return readString();
           }
       }
    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();
           }
           public void flush() {
               writer.flush();
           }
           }
       /**
        * @param args
        */
       InputReader in= new InputReader(System.in);
       OutputWriter out = new OutputWriter(System.out);
       StringTokenizer tok;
           public static void main(String[] args) throws IOException
           {
              new Main().run();
           }
           void run() throws IOException
           {      
              solve();
              out.flush();
              tok=null;
           }
          
           void solve() throws IOException{
        	int n=in.readInt();
        	int a=in.readInt();
        	int b=in.readInt();
        	int T=in.readInt();
        	int[] L=new int[n];
        	int[] R=new int[n];
        	String ln=in.readString();
        	for (int i=0;i<n;++i){
        			L[i]=1;
        			if (ln.charAt(i)=='w'){
        				L[i]+=b;
        			}
        		if (i>0){
        			L[i]+=L[i-1]+a;
        		}
        	}
        	for (int i=n-1;i>0;--i){
        		R[i]=1;
    			if (ln.charAt(i)=='w'){
    				R[i]+=b;
    			}
    		if (i<n-1){
    			R[i]+=R[i+1]+a;
    		}
        	}
        	int max_seen=0;
        	for (int i=0;i<n;++i){
        		if (L[i]>T) break;
        		int rem=T-L[i]- (i+1)*a;
        		
        		int l=i+1;
        		int r=n-1;
        		int d=-1;
        		while (l<=r){
        			int m=(l+r)/2;
        			//System.out.println(m+","+R[m]);
        			if (R[m]>rem){
        				l=m+1;
        			}else{
        				d=m;
        				r=m-1;
        			}
        		}int  seen= (i+1);
        		if (d>-1){
        			//System.out.println(i+","+d);
        			 seen+=+ (n-d);
        			
        		}
        		max_seen=Math.max(seen, max_seen);
        		} 
        	int nT=T-L[0]-a;
        	for (int i=n-1;i>0;--i){
        		
        		if (R[i]>nT) break;
        		int rem=nT-R[i]- (n-i)*a ;
        		int seen=(n-i)+1;
        		int l=1;
        		int r=i-1;
        		int d=-1;
        		while (l<=r){
        			int m=(l+r)/2;
        			if (L[m]-L[0] > rem){
        				r=m-1;
        			}else{
        				d=m;
        				l=m+1;
        			}
        		}
        		if (d>-1){
        			 seen+= d;
        			
        		}
        		max_seen=Math.max(seen, max_seen);
        	} 
        	out.printLine(max_seen);
        	
    }}