#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e4 + 10;
const int mod = 1e9 + 7;
char s[707];
int n, rec[707];
long long dp[707][707][10];
vector<int> v;
int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  ;
  cin >> (s + 1);
  n = strlen(s + 1);
  for (int i = 1; i <= n; i++)
    if (s[i] == '(')
      v.push_back(i);
    else {
      int x = v[(int)v.size() - 1];
      rec[x] = i;
      v.pop_back();
    }
  for (int i = 1; i < n; i++)
    if (s[i] == '(' && s[i + 1] == ')') {
      dp[i][i + 1][1] = 1;
      dp[i][i + 1][2] = 1;
      dp[i][i + 1][3] = 1;
      dp[i][i + 1][6] = 1;
    }
  for (int len = 3; len <= n; len++)
    for (int l = 1; len + l - 1 <= n; l++) {
      int r = l + len - 1;
      if (s[l] == '(' && s[r] == ')') {
        int x = rec[l];
        if (x == r) {
          dp[l][r][1] = (dp[l + 1][r - 1][0] + dp[l + 1][r - 1][2] +
                         dp[l + 1][r - 1][3] + dp[l + 1][r - 1][5] +
                         dp[l + 1][r - 1][6] + dp[l + 1][r - 1][8]) %
                        mod;
          dp[l][r][2] = (dp[l + 1][r - 1][0] + dp[l + 1][r - 1][1] +
                         dp[l + 1][r - 1][3] + dp[l + 1][r - 1][4] +
                         dp[l + 1][r - 1][6] + dp[l + 1][r - 1][7]) %
                        mod;
          dp[l][r][3] = (dp[l + 1][r - 1][0] + dp[l + 1][r - 1][1] +
                         dp[l + 1][r - 1][2] + dp[l + 1][r - 1][6] +
                         dp[l + 1][r - 1][7] + dp[l + 1][r - 1][8]) %
                        mod;
          dp[l][r][6] = (dp[l + 1][r - 1][0] + dp[l + 1][r - 1][1] +
                         dp[l + 1][r - 1][2] + dp[l + 1][r - 1][3] +
                         dp[l + 1][r - 1][4] + dp[l + 1][r - 1][5]) %
                        mod;
          continue;
        }
        dp[l][r][0] =
            (dp[l][r][0] + (dp[l][x][0] * (dp[x + 1][r][0] + dp[x + 1][r][3] +
                                           dp[x + 1][r][6])) %
                               mod) %
            mod;
        dp[l][r][0] =
            (dp[l][r][0] +
             (dp[l][x][1] * (dp[x + 1][r][0] + dp[x + 1][r][6])) % mod) %
            mod;
        dp[l][r][0] =
            (dp[l][r][0] +
             (dp[l][x][2] * (dp[x + 1][r][0] + dp[x + 1][r][3])) % mod) %
            mod;
        dp[l][r][1] =
            (dp[l][r][1] + (dp[l][x][0] * (dp[x + 1][r][1] + dp[x + 1][r][4] +
                                           dp[x + 1][r][7])) %
                               mod) %
            mod;
        dp[l][r][1] =
            (dp[l][r][1] +
             (dp[l][x][1] * (dp[x + 1][r][1] + dp[x + 1][r][7])) % mod) %
            mod;
        dp[l][r][1] =
            (dp[l][r][1] +
             (dp[l][x][2] * (dp[x + 1][r][1] + dp[x + 1][r][4])) % mod) %
            mod;
        dp[l][r][2] =
            (dp[l][r][2] + (dp[l][x][0] * (dp[x + 1][r][2] + dp[x + 1][r][5] +
                                           dp[x + 1][r][8])) %
                               mod) %
            mod;
        dp[l][r][2] =
            (dp[l][r][2] +
             (dp[l][x][1] * (dp[x + 1][r][2] + dp[x + 1][r][8])) % mod) %
            mod;
        dp[l][r][2] =
            (dp[l][r][2] +
             (dp[l][x][2] * (dp[x + 1][r][2] + dp[x + 1][r][5])) % mod) %
            mod;
        dp[l][r][3] =
            (dp[l][r][3] + (dp[l][x][3] * (dp[x + 1][r][0] + dp[x + 1][r][3] +
                                           dp[x + 1][r][6])) %
                               mod) %
            mod;
        dp[l][r][3] =
            (dp[l][r][3] +
             (dp[l][x][4] * (dp[x + 1][r][0] + dp[x + 1][r][6])) % mod) %
            mod;
        dp[l][r][3] =
            (dp[l][r][3] +
             (dp[l][x][5] * (dp[x + 1][r][0] + dp[x + 1][r][3])) % mod) %
            mod;
        dp[l][r][4] =
            (dp[l][r][4] + (dp[l][x][3] * (dp[x + 1][r][1] + dp[x + 1][r][4] +
                                           dp[x + 1][r][7])) %
                               mod) %
            mod;
        dp[l][r][4] =
            (dp[l][r][4] +
             (dp[l][x][4] * (dp[x + 1][r][1] + dp[x + 1][r][7])) % mod) %
            mod;
        dp[l][r][4] =
            (dp[l][r][4] +
             (dp[l][x][5] * (dp[x + 1][r][1] + dp[x + 1][r][4])) % mod) %
            mod;
        dp[l][r][5] =
            (dp[l][r][5] + (dp[l][x][3] * (dp[x + 1][r][2] + dp[x + 1][r][5] +
                                           dp[x + 1][r][8])) %
                               mod) %
            mod;
        dp[l][r][5] =
            (dp[l][r][5] +
             (dp[l][x][4] * (dp[x + 1][r][2] + dp[x + 1][r][8])) % mod) %
            mod;
        dp[l][r][5] =
            (dp[l][r][5] +
             (dp[l][x][5] * (dp[x + 1][r][2] + dp[x + 1][r][5])) % mod) %
            mod;
        dp[l][r][6] =
            (dp[l][r][6] + (dp[l][x][6] * (dp[x + 1][r][0] + dp[x + 1][r][3] +
                                           dp[x + 1][r][6])) %
                               mod) %
            mod;
        dp[l][r][6] =
            (dp[l][r][6] +
             (dp[l][x][7] * (dp[x + 1][r][0] + dp[x + 1][r][6])) % mod) %
            mod;
        dp[l][r][6] =
            (dp[l][r][6] +
             (dp[l][x][8] * (dp[x + 1][r][0] + dp[x + 1][r][3])) % mod) %
            mod;
        dp[l][r][7] =
            (dp[l][r][7] + (dp[l][x][6] * (dp[x + 1][r][1] + dp[x + 1][r][4] +
                                           dp[x + 1][r][7])) %
                               mod) %
            mod;
        dp[l][r][7] =
            (dp[l][r][7] +
             (dp[l][x][7] * (dp[x + 1][r][1] + dp[x + 1][r][7])) % mod) %
            mod;
        dp[l][r][7] =
            (dp[l][r][7] +
             (dp[l][x][8] * (dp[x + 1][r][1] + dp[x + 1][r][4])) % mod) %
            mod;
        dp[l][r][8] =
            (dp[l][r][8] + (dp[l][x][6] * (dp[x + 1][r][2] + dp[x + 1][r][5] +
                                           dp[x + 1][r][8])) %
                               mod) %
            mod;
        dp[l][r][8] =
            (dp[l][r][8] +
             (dp[l][x][7] * (dp[x + 1][r][2] + dp[x + 1][r][8])) % mod) %
            mod;
        dp[l][r][8] =
            (dp[l][r][8] +
             (dp[l][x][8] * (dp[x + 1][r][2] + dp[x + 1][r][5])) % mod) %
            mod;
      }
    }
  int ans = 0;
  for (int i = 0; i < 9; i++) ans = (ans + dp[1][n][i]) % mod;
  cout << ans;
  return 0;
}
