We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7.

The string "ab" appears as a substring if there is a letter 'b' right after the letter 'a' somewhere in the string.

Input

The first line contains the initial string consisting of letters 'a' and 'b' only with length from 1 to 106.

Output

Print the minimum number of steps modulo 109 + 7.

Examples

Input

ab


Output

1


Input

aab


Output

3

Note

The first example: "ab"  →  "bba".

The second example: "aab"  →  "abba"  →  "bbaba"  →  "bbbbaa".
 // Importing all important imports
     
    import java.awt.Point;
    import static java.lang.System.in;
    import java.io.BufferedReader;
    import java.io.ByteArrayInputStream;
    import java.io.DataInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintStream;
    import java.io.PrintWriter;
    import java.math.BigInteger;
    import java.math.BigDecimal;
    import java.math.MathContext;
    import java.math.RoundingMode;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.BitSet;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.Date;
    import java.util.GregorianCalendar;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Hashtable;
    import java.util.InputMismatchException;
    import java.util.LinkedHashMap;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Stack;
    import java.util.Queue;
    import java.util.Random;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import java.util.Set;
    import java.util.SortedSet;
    import java.util.StringTokenizer;
    import java.util.TreeMap;
    import java.util.TreeSet;
    import java.util.Vector;
     
     
     
    /**
    @author
    * 
    $$\      $$\            $$$$$$\            
    $$$\    $$$ |          $$  __$$\           
    $$$$\  $$$$ | $$$$$$$\ $$ /  \__|  
    $$\$$\$$ $$ |$$  _____|$$$$\      
    $$ \$$$  $$ |\$$$$$$\  $$  _|     
    $$ |\$  /$$ | \____$$\ $$ |      
    $$ | \_/ $$ |$$$$$$$  |$$ |      
    \__|     \__|\_______/ \__|       
    *
    * @Mustafa Filmwala
    * @filmwalams@gmail.com
    * https://github.com/filmwalams/JAVA-Functions
    * 
    * 
    */
     
	public class Main{
            
            static boolean testcase=false;
            static boolean debug_mode=false;
            static String input_file_name="";
            static String output_file_name="";
            
            //static String input_file_name="input.txt";
            //static String output_file_name="output.txt";
            
            public int mod=1000000007;
  			public long fastmodpow(long base,long exp,int mod){
  				long result = 1;
  				while(exp > 0){
  					if(exp % 2 == 1){
  						result  = (result * base)%mod;
  					}
  					base = (base * base) % mod;
  					exp /= 2;
  				}
  				return result%mod;
  			}
            public void solve(int tc) throws IOException           {   
            	String s = ns().trim();
            	long a = 0;
            	long b = 0;
            	long ans = 0;
            	for(int i = 0;i < s.length();i++){
            		if(s.charAt(i) == 'a')a++;
            		else{
            			b++;
            			ans = (ans + fastmodpow(2,a,mod) + mod - 1)%mod;
            		}
            	}
            	System.out.println(ans);
            	
			}
            
     
            // END OF SOLUTION
            
            public void precompute(){}
            
            
            // INPUT OUTPUT TEMPLATE
            static String TESTCASES="";
            static PrintWriter out;
            static int Space;
            
            public static void main(String[] args) throws Exception{
                    // generateTestCases(1); 
                    long endTime,startTime=System.currentTimeMillis();
                    if(output_file_name.isEmpty())
    					out=new PrintWriter(new OutputStreamWriter(System.out));
                    else
    					out = new PrintWriter(new FileOutputStream("/home/filmwalams/Desktop/CONTEST/"+output_file_name));
                    //if(!input_file_name.isEmpty()){
    				//	mytestcases();
    				//}
                    InputStream myinp=TESTCASES.isEmpty() ? System.in : new ByteArrayInputStream(TESTCASES.getBytes());
                    init(myinp);
                    
                    Space=0;
                    Main program=new Main();
                    
                    program.precompute();
                    if(testcase==true){int test=ni();for(int tc=1;tc<=test;tc++)program.solve(tc);}
                    else program.solve(0);
                    
                    out.close();
                    endTime=System.currentTimeMillis();
                    //printTime("Time: "+(endTime-startTime)+"ms");
            }
            
            // Testcases reader from FILE. If file not found, input is taken from console.
            public static void mytestcases(){
    			
                try{
    				TESTCASES=new String(Files.readAllBytes(Paths.get("/home/filmwalams/Desktop/CONTEST/"+input_file_name)));
                }
                catch(Exception e){
    				TESTCASES="";
    			}
            }
            
            public static void generateTestCases(int count){
    			
                PrintStream console=System.out;
                try{
    				PrintStream out = new PrintStream(new FileOutputStream("/home/filmwalams/Downloads"));
                
    				System.setOut(out);
    				Random r=new Random();
    				// System.out.println(count);
    				for(int tc=0;tc<count;tc++){
    					   
    				}
    				System.setOut(console);
                }
                catch(FileNotFoundException fe){
    				System.setOut(console);
    			}
            }
              
              
            // Just to print time, not to use anywhere else
            public static void printTime(Object ...obj){System.err.println(Arrays.deepToString(obj));}
            static InputStream is;
            static BufferedReader brr;
            protected static byte[] inbuf = new byte[1024];
            static int lbuffer = 0, pbuffer = 0;
            public static void init(InputStream input) {is=input;brr=new BufferedReader(new InputStreamReader(input));}
            // Fundamental
            protected static int rb(){if(lbuffer == -1)throw new InputMismatchException();if(pbuffer >= lbuffer){pbuffer = 0;try { lbuffer = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }if(lbuffer <= 0)return -1;}return inbuf[pbuffer++];}       
            protected static String line() throws IOException{return brr.readLine();}   
            protected static boolean isSpace(int c) { return !(c >= 33 && c <= 126); }
            protected static int skip(){ int b; while((b = rb()) != -1 && isSpace(b)); return b; }
            // Inputs
            protected static double nd() throws IOException { return Double.parseDouble(ns()); }
            protected static char nc() { return (char)skip(); }
            protected static String ns() throws IOException{if(Space==1)return line();int b = skip();StringBuilder sb = new StringBuilder();while(!(isSpace(b))){ sb.appendCodePoint(b);b = rb();}return sb.toString();}
            protected static char[] nca(int n){char[] buf = new char[n];int b = skip(), p = 0;while(p < n && !(isSpace(b))){buf[p++] = (char)b;b = rb();} return n == p ? buf : Arrays.copyOf(buf, p);}
            protected static int[] nia(int n) throws IOException{int[] a = new int[n];for(int i = 0;i < n;i++)a[i] = ni();return a;}
            protected static int[][] niaindex(int n) throws IOException{int ea[][]=new int[n][2];for(int i=0;i<n;i++){ea[i][0]=ni();ea[i][1]=i;}return ea;}
            protected static long[] nla(int n) throws IOException{long[] a = new long[n];for(int i = 0;i < n;i++)a[i] = nl();return a;}
            protected static long[][] nlaindex(int n) throws IOException{long ea[][]=new long[n][2];for(int i=0;i<n;i++){ea[i][0]=ni();ea[i][1]=i;}return ea;}
            protected static String[] nsa(int n) throws IOException{String[] a = new String[n];for(int i = 0;i < n;i++)a[i] = ns();return a;    }
            protected static double[] nda(int n) throws IOException{double[] a = new double[n];for(int i = 0;i < n;i++)a[i] = nd();return a;}
            protected static int ni() throws IOException{if(Space==1)return Integer.parseInt(line());int num=0,b;boolean minus = false;while((b = rb())!= -1 && !((b>='0'&&b<='9') || b =='-'));if(b =='-'){minus=true;b = rb();    }while(true){if(b >= '0' && b <= '9'){num = num * 10 + (b - '0');}else{return minus ? -num : num;}b = rb();}}  
            protected static long nl() throws IOException{if(Space==1)return Long.parseLong(line());long num = 0;int b;boolean minus = false;while((b = rb()) != -1 && !((b >= '0' && b <= '9') || b == '-'));if(b == '-'){   minus = true;b = rb();}while(true){if(b >= '0' && b <= '9'){num = num * 10 + (b - '0');}else{return minus ? -num : num;}b = rb();}}
            // Outputs
            public static void pln(){out.println();}
            public static void ps(String s){out.print(s);}
            public static void pi(int s){out.print(s);}
            public static void pl(long s){out.print(s);}
            public static void pd(double s){out.print(s);}
            public static void psp(){out.print(" ");}
            public static void parr(int s[]){out.println(Arrays.toString(s));}
            public static void parr(String s[]){out.println(Arrays.toString(s));}
            public static void parr(long s[]){out.println(Arrays.toString(s));}        
            public static void parr2(int s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
            public static void parr2(long s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
            public static void parr2(String s[][]){for(int i=0;i<s.length;i++)out.println(Arrays.toString(s[i]));}
            
            
    }   