#include <fstream>
#include <vector>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;

const int kMod = 1e9 + 7;

class Task {
 public:
    void solve() {
        read_input();
        print_output(get_result());
    }

 private:
    int n;
    string expr;

    void read_input() {
        ifstream fin("in");
        fin >> n >> expr;
        expr = " " + expr; // adaugare caracter fictiv - indexare de la 1
        fin.close();
    }

    int get_result() {
        /*
        Calculati numarul de parantezari ale expresiei date astfel incat
        rezultatul sa dea true si returnati restul impartirii numarului
        la 10^9 + 7.
        */

        int DP_F[1000][1000], DP_T[1000][1000];
        int sym = 0;
        int op = 0;
        char symbols[n];
        char operators[n];

        for (int i = 1; i <= n; i++){
            if (expr.at(i) == 'T' || expr.at(i) == 'F') {
                symbols[sym++] = expr.at(i);
            } else {
                operators[op++] = expr.at(i);
            }
        }

        for (int i = 0; i < sym; i++) {
            if (symbols[i] == 'T') {
                DP_T[i][i] = 1;
                DP_F[i][i] = 0;
            } else {
                DP_T[i][i] = 0;
                DP_F[i][i] = 1;
            }
        }

        for (int i = 1; i < sym; i++) {
            for (int j = 0; j < sym - i; j++) {
                int p = j + i;

                DP_T[j][p] = 0;
                DP_F[j][p] = 0;

                for (int k = j; k < p; k++) {
                    int sum1 = (DP_T[j][k] + DP_F[j][k]) % kMod;
                    int sum2 = (DP_T[k+1][p] + DP_F[k+1][p]) % kMod;

                    if (operators[k] == '^') {
                        DP_T[j][p] = (1LL * DP_F[j][k] * DP_T[k+1][p] + 1LL * DP_T[j][k] * DP_F[k+1][p] +
                                     DP_T[j][p]) % kMod;
                        DP_F[j][p] = (1LL * DP_T[j][k] * DP_T[k+1][p] + 1LL * DP_F[j][k] * DP_F[k+1][p] +
                                    DP_F[j][p]) % kMod;
                    }

                    if (operators[k] == '|') {
                        DP_T[j][p] = (1LL * sum1 * sum2 - 1LL * DP_F[j][k] * DP_F[k+1][p] +
                                DP_T[j][p]) % kMod;
                        if (DP_T[j][p] < 0)
                            DP_T[j][p] += kMod; // this must be done as C++ doesn't handle well
                                                // negative values with modulo
                        DP_F[j][p] = (1LL * DP_F[j][k] * DP_F[k+1][p] + DP_F[j][p]) % kMod;
                    }

                    if (operators[k] == '&') {
                        DP_T[j][p] = (1LL * DP_T[j][k] * DP_T[k+1][p] + DP_T[j][p]) % kMod;
                        DP_F[j][p] = (1LL * sum1 * sum2 - 1LL * DP_T[j][k] * DP_T[k+1][p] +
                                     DP_F[j][p]) % kMod;
                        if (DP_F[j][p] < 0)
                            DP_F[j][p] += kMod;
                    }
                }
            }
        }

        return DP_T[0][sym - 1];
    }

    void print_output(int result) {
        ofstream fout("out");
        fout << result << '\n';
        fout.close();
    }
};

int main() {
    Task task;
    task.solve();
    return 0;
}