The Fair Nut found a string s. The string consists of lowercase Latin letters. The Nut is a curious guy, so he wants to find the number of strictly increasing sequences p_1, p_2, …, p_k, such that: 

  1. For each i (1 ≤ i ≤ k), s_{p_i} = 'a'. 
  2. For each i (1 ≤ i < k), there is such j that p_i < j < p_{i + 1} and s_j = 'b'. 



The Nut is upset because he doesn't know how to find the number. Help him.

This number should be calculated modulo 10^9 + 7.

Input

The first line contains the string s (1 ≤ |s| ≤ 10^5) consisting of lowercase Latin letters.

Output

In a single line print the answer to the problem — the number of such sequences p_1, p_2, …, p_k modulo 10^9 + 7.

Examples

Input

abbaa


Output

5

Input

baaaa


Output

4

Input

agaa


Output

3

Note

In the first example, there are 5 possible sequences. [1], [4], [5], [1, 4], [1, 5].

In the second example, there are 4 possible sequences. [2], [3], [4], [5].

In the third example, there are 3 possible sequences. [1], [3], [4].
#_________________ Mukul Mohan Varshney _______________#

#Template
import sys
import os
import math
import copy
from math import gcd
from bisect import bisect
from io import BytesIO, IOBase
from math import sqrt,floor,factorial,gcd,log,ceil
from collections import deque,Counter,defaultdict
from itertools import permutations, combinations

#define function 
def Int(): return int(sys.stdin.readline())
def Mint(): return map(int,sys.stdin.readline().split())
def Lstr(): return list(sys.stdin.readline().strip())
def Str(): return sys.stdin.readline().strip()
def Mstr(): return map(str,sys.stdin.readline().strip().split())
def List(): return list(map(int,sys.stdin.readline().split()))
def Hash(): return dict()
def Mod(): return 1000000007
def Ncr(n,r,p): return ((fact[n])*((ifact[r]*ifact[n-r])%p))%p
def Most_frequent(list): return max(set(list), key = list.count)
def Mat2x2(n): return [List() for _ in range(n)]

def Prime_factors(n):
     i = 2
     factors = set()
     while i * i <= n:
          if n % i:
               i += 1
          else:
               n //= i
               factors.add(i)
     if n > 1:
          factors.add(n)
     print(factors)     
     if len(factors)==2:
          return True
     else:
          return False

def Divisors(n) : 
     l = []  
     for i in range(1, int(math.sqrt(n) + 1)) :
          if (n % i == 0) : 
               if (n // i == i) : 
                    l.append(i) 
               else : 
                    l.append(i)
                    l.append(n//i)
     return l
     
def Sieve(n):                      
     prime=[True for i in range(n+1)]
     lst=[]
     p=2
     while p*p<=n:
          if prime[p]:
               for i in range(p*p,n+1,p):
                    prime[i]=False
          p=p+1
     for i in range(2,n+1):
          if prime[i]:
               lst.append(i)
     return lst    
     
def minimum_integer_not_in_list(a):
     b=max(a)
     if(b<1):
          return 1
          
     A=set(a)
     B=set(range(1,b+1))
     D=B-A
     if len(D)==0:
          return b+1
     else:
          return min(D)
 
# Driver Code 	
def solution():
     s=Lstr()
     ans=[0,0]
     for i in range(len(s)):
          if(s[i]=='b'):
               ans[1]=ans[0]
          elif(s[i]=='a'):
               ans[0]=(sum(ans)+1)%Mod()
     print(ans[0]%Mod())          

#Call the solve function          
if __name__ == "__main__":
     solution()  