One day Nikita found the string containing letters "a" and "b" only. 

Nikita thinks that string is beautiful if it can be cut into 3 strings (possibly empty) without changing the order of the letters, where the 1-st and the 3-rd one contain only letters "a" and the 2-nd contains only letters "b".

Nikita wants to make the string beautiful by removing some (possibly none) of its characters, but without changing their order. What is the maximum length of the string he can get?

Input

The first line contains a non-empty string of length not greater than 5 000 containing only lowercase English letters "a" and "b". 

Output

Print a single integer — the maximum possible size of beautiful string Nikita can get.

Examples

Input

abba


Output

4

Input

bab


Output

2

Note

It the first sample the string is already beautiful.

In the second sample he needs to delete one of "b" to make it beautiful.
''' ===============================
    -- @uthor : Kaleab Asfaw
    -- Handle : kaleabasfaw2010
    -- Bio    : High-School Student
    ==============================='''

# Fast IO
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file): self._fd = file.fileno(); self.buffer = BytesIO(); self.writable = "x" in file.mode or "r" not in file.mode; self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b: break
            ptr = self.buffer.tell(); self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0; return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE)); self.newlines = b.count(b"\n") + (not b); ptr = self.buffer.tell(); self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1; return self.buffer.readline()
    def flush(self):
        if self.writable: os.write(self._fd, self.buffer.getvalue()); self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file): self.buffer = FastIO(file); self.flush = self.buffer.flush; self.writable = self.buffer.writable; self.write = lambda s: self.buffer.write(s.encode("ascii")); self.read = lambda: self.buffer.read().decode("ascii"); self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout); input = lambda: sys.stdin.readline().rstrip("\r\n")
# Others
# from math import floor, ceil, gcd
# from decimal import Decimal as d
mod = 10**9+7
def lcm(x, y): return (x * y) / (gcd(x, y))
def fact(x, mod=mod):
    ans = 1
    for i in range(1, x+1): ans = (ans * i) % mod
    return ans
def arr2D(n, m, default=0): return [[default for j in range(m)] for i in range(n)]
def arr3D(n, m, r, default=0): return [[[default for k in range(r)] for j in range(m)] for i in range(n)]
def sortDictV(x): return {k: v for k, v in sorted(x.items(), key = lambda item : item[1])}
class DSU:
    def __init__(self, length): self.length = length; self.parent = [-1] * self.length  # O(log(n))
    def getParent(self, node, start):  # O(log(n))
        if node >= self.length: return False
        if self.parent[node] < 0:
            if start != node: self.parent[start] = node
            return node
        return self.getParent(self.parent[node], start)
    def union(self, node1, node2):  # O(log(n))
        parent1 = self.getParent(node1, node1); parent2 = self.getParent(node2, node2)
        if parent1 == parent2: return False
        elif self.parent[parent1] <= self.parent[parent2]: self.parent[parent1] += self.parent[parent2]; self.parent[parent2] = parent1
        else: self.parent[parent2] += self.parent[parent1]; self.parent[parent1] = parent2
        return True
    def getCount(self, node):  return -self.parent[self.getParent(node, node)] # O(log(n))

def exact(num):
    if abs(num - round(num)) <= 10**(-9):return round(num)
    return num

def solve(lst):
    a = 0
    b = 0
    bestPref = -1
    maxx = 0
    n = len(lst)

    for i in range(n):
        if lst[i] == "a": a += 1
        else: b += 1
        if (a-b) > maxx:
            maxx = a-b
            bestPref = i

    lst = lst[::-1]
    a = 0
    b = 0 
    bestSuf = -1
    maxx = 0
    
    for i in range(n):
        if lst[i] == "a": a += 1
        else: b += 1
        if (a-b) > maxx:
            maxx = a-b
            bestSuf = i
    
    bestSuf = n-bestSuf-1
    lst = lst[::-1]
    # print(bestPref, bestSuf)

    # if lst[:len("bbaababababaaaaaa")] == list("bbaababababaaaaaa"):
    #     print(bestPref, bestSuf)
    if bestSuf <= bestPref:
        # cnt = 0
        # maxxCount = 0
        # # for i in range(bestSuf, bestPref+1):
        # for i in range(n):
        #     if lst[i] == "b": cnt += 1
        #     else: cnt = 0
        #     maxxCount = max(maxxCount, cnt)
        # # print(maxxCount)

        maxxDiff = 0
        ind = (0, -1)
        for i in range(n):
            aa = 0
            bb = 0
            for j in range(i, n):
                if lst[j] == "a": aa += 1
                else: bb += 1
                if bb - aa > maxxDiff:
                    maxxDiff = bb - aa
                    ind = (i, j)
        # print(ind)

        aa = 0
        bb = 0
        for i in range(ind[0], ind[1] + 1):
            if lst[i] == "a": aa += 1
            else: bb += 1
        # print(aa, bb)
        cnta = 0
        for i in lst:
            if i == "a": cnta += 1
        return cnta - aa + bb
    elif bestPref == -1 and bestSuf == n:
        cntb = 0
        for i in lst:
            if i == "b": cntb += 1
        return cntb
    else: 
        cnta = 0
        for i in range(0, bestPref+1):
            if lst[i] == "a":
                cnta += 1
        for i in range(bestSuf, n):
            # print(lst[i])
            if lst[i] == "a":
                cnta += 1
        
        for i in range(bestPref+1, bestSuf):
            if lst[i] == "b": cnta += 1
        return cnta


lst = list(input())
print(solve(lst))