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".
import java.io.*;
import java.util.*;

public class ProblemD {

    public static void main(String[] args) throws IOException {
        init();
        new ProblemD().run();
        out.flush();
        out.close();
    }

    static void init() throws IOException {
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(new OutputStreamWriter(System.out));
        in.ordinaryChars(0, 65535);
        in.wordChars(0, 65535);
        in.whitespaceChars(' ', ' ');
        in.whitespaceChars('\n', '\n');
        in.whitespaceChars('\r', '\r');
    }

    // класс для пар
    class Pair<L, R> {
        private final L X;
        private final R Y;

        public Pair(L X, R Y) {
            this.X = X;
            this.Y = Y;
        }

        public L getX() {
            return X;
        }

        public R getY() {
            return Y;
        }

        @Override
        public int hashCode() {
            return X.hashCode() ^ Y.hashCode();
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Pair)) return false;
            Pair pairo = (Pair) o;
            return X.equals(pairo.getX()) && Y.equals(pairo.getY());
        }
    }

    static final long INFL = 200000000000000000L;
    static final int INF = 2000000000;
    static final boolean DEBUG = true;

    static StreamTokenizer in;
    static PrintWriter out;

    static void print(String s) {
        print(s, 0);
    }

    static void print(String s, int debug) {
        if (debug == 0 || DEBUG) {
            out.print(s);
        }
    }

    static void println(String s) {
        println(s, 0);
    }

    static void println(String s, int debug) {
        if (debug == 0 || DEBUG) {
            out.println(s);
        }
    }

    static void printArray(int[] arr) {
        println(Arrays.toString(arr));
    }

    static void printArray(char[] arr) {
        println(Arrays.toString(arr));
    }

    static void printArray(String[] arr) {
        println(Arrays.toString(arr));
    }

    static void sort(int[] a) {
        Random rnd = new Random();
        for (int i = a.length - 1; i > 0; i--) {
            int index = rnd.nextInt(i);
            a[i] ^= a[index];
            a[index] ^= a[i];
            a[i] ^= a[index];
        }
        Arrays.sort(a);
    }

    static char[] inChars;
    static int inCharsInd;

    static String next() throws IOException {
        in.nextToken();
        return in.sval;
    }

    static char nextChar() throws IOException {
        while (inChars == null || inCharsInd >= inChars.length) {
            inChars = next().toCharArray();
            inCharsInd = 0;
        }
        return inChars[inCharsInd++];
    }

    static int nextInt() throws IOException {
        return Integer.valueOf(next());
    }

    static double nextDouble() throws IOException {
        return Double.valueOf(next());
    }

    static long nextLong() throws IOException {
        return Long.valueOf(next());
    }

    private void run() throws IOException {
        solve();
    }

    int K, L, M, N, P;
    static int MODULE = (int)Math.pow(10, 9) + 7;

    private void solve() throws IOException {
        char[] chars = next().toCharArray();

        long answer = 0;
        int curIndex = chars.length - 1;
        long countOfB = 0;
        while (curIndex >= 0){
            if (chars[curIndex] == 'b'){
                countOfB++;
            } else {
                answer+=countOfB;
                countOfB*=2;
                countOfB%=MODULE;
                answer%=MODULE;
            }
            curIndex--;
        }
        out.println(answer);
    }

}