MOD = 10 ** 9 + 7

class SegmentTree:
    def __init__(self, data, default=0, func=max):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        """func of data[start, stop)"""
        start += self._size
        stop += self._size

        res_left = res_right = self._default
        while start < stop:
            if start & 1:
                res_left = self._func(res_left, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res_right = self._func(self.data[stop], res_right)
            start >>= 1
            stop >>= 1

        return self._func(res_left, res_right)

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

t = int(input())
for test in range(t):
    s = input().strip()
    n = len(s)

    less = []
    eq = []
    force = []
    gold = [1]

    on = SegmentTree([1] + [0] * n, func = lambda x, y: x + y)
    off = [1] + [0] * n

    spread = []

    for i in range(n):
        c = s[i]

        ns = []
        for v in spread:
            if off[v - 1] == 0:
                off[v - 1] = 1
                on[v - 1] = 0
                ns.append(v - 1)
        spread = ns

        if c == '=':
            eq.append(i)
            gold.append(0)
            continue

        if c == '<':
            less.append(i)
            gold.append(0)
            continue

        if c == '>':
            spread.append(i + 1)
            gold.append(0)
            continue

        left_bound = -1

        if force:
            left_bound = max(force[-1], left_bound)
        if len(eq) >= 2:
            left_bound = max(eq[-2]+ 1, left_bound)
        if less:
            left_bound = max(2 * less[-1] - i + 1, left_bound)
            left_bound = max(0, left_bound)

        #Remaining info:
            #eq[-1]
            #>

        res = 0

        if eq:
            left_bound = max(0, left_bound)
            if 2 * eq[-1] - i >= left_bound:
                res += on[2 * eq[-1] - i + 1]
            left_bound = max(eq[-1]+ 1, left_bound)

        res += on.query(left_bound + 1, i + 1) 

        if c == 'o':
            force.append(i)

        res %= MOD
        gold.append(res)
        on[i + 1] = res

    rr = 0
    
    for i in range(n - 1, -1, -1):
        if s[i] in '>=':
            break

        rr += gold[i + 1]

        if s[i] == 'o':
            break

    #print(gold)
    #print(rr % MOD)
    print(f'Case #{test + 1}: {rr % MOD}')