#!/usr/bin/env python3

# université pierre et marie curie - c. dürr - 2017
# http://www-desir.lip6.fr/~durrc/Iut/cpa/tme5-progdyn/

# Compter le nombre de parenthésages booléens
# algorithme: prod-dyn sur des intervalles
# complexité: O(n^3)

from sys import stdin
from pprint import pprint


def readint():
    return int(stdin.readline())

def readints():
    return map(int, stdin.readline().split())

def readstrings():
    return stdin.readline().split()


OPVAL = {
 "and": [[0, 0], [0, 1]],
 "or":  [[0, 1], [1, 1]],
 "xor": [[0, 1], [1, 0]]
 }

def parenthesis(L):
    """
    On numérote les constantes dans L de 0 à n-1.
    La i-ème constante est val[i] =  L[2 * i]
    On numérote les opérateurs dans L de 0 à n-2.
    Le i-ème opérateur est op[i] = L[2 * i + 1]

    Une parenthèse gauche est devant une constante et une parenthèse droite après.

    A[i][j][v] = nombre de façons de placer les parenthèses sur l'expression
    entre la i-ème et la j-ème constante tel que la valeur de l'expression
    soit v.

    A[i][i][v] = 1 si val[i] est v et 0 sinon

    Pour i < j il faut itérer sur toutes les positions k du dernier opérateur appliqué :

    A[i][j][v] = la somme sur i ≤ k < j de A[i][k][a] * A[k+1][j][b] avec a op[k] b = v.

    L'idée clé est de traiter les couples (i,j) avec j-i croissant.

    complexité:
        O(n^3) variables, évaluation en temps constant
    """
    assert len(L) % 2 == 1
    n = (len(L) + 1 ) // 2
    A = [[[0 for v in range(2)] for j in range(n)] for i in range(n)]
    # --- cas de base
    for i in range(n):
        val = int( L[2 * i] == "true" )
        A[i][i][val] = 1
    # --- récursion
    for diff in range(1, n):
        for i in range(n - diff):
            j = i + diff
            for k in range(i, j):
                for a in range(2):
                    for b in range(2):
                        op = L[2 * k + 1]
                        v = OPVAL[op][a][b]
                        A[i][j][v] = ( A[i][j][v] + A[i][k][a] * A[k + 1][j][b] ) % 100000007
    return A[0][n-1][1]

n = readint()
L = readstrings()
print(parenthesis(L))