As Famil Door’s birthday is coming, some of his friends (like Gabi) decided to buy a present for him. His friends are going to buy a string consisted of round brackets since Famil Door loves string of brackets of length *n* more than any other strings!

The sequence of round brackets is called valid if and only if: 
 1.  the total number of opening brackets is equal to the total number of closing brackets; 1.  for any prefix of the sequence, the number of opening brackets is greater or equal than the number of closing brackets. 
Gabi bought a string *s* of length *m* (*m* ≤ *n*) and want to complete it to obtain a valid sequence of brackets of length *n*. He is going to pick some strings *p* and *q* consisting of round brackets and merge them in a string *p* + *s* + *q*, that is add the string *p* at the beginning of the string *s* and string *q* at the end of the string *s*.

Now he wonders, how many pairs of strings *p* and *q* exists, such that the string *p* + *s* + *q* is a valid sequence of round brackets. As this number may be pretty large, he wants to calculate it modulo 10<sup class="upper-index">9</sup> + 7.
First line contains *n* and *m* (1 ≤ *m* ≤ *n* ≤ 100 000, *n* - *m* ≤ 2000) — the desired length of the string and the length of the string bought by Gabi, respectively.

The second line contains string *s* of length *m* consisting of characters '(' and ')' only.
In the first sample there are four different valid pairs: 
 1.  *p* = "(", *q* = "))" 1.  *p* = "()", *q* = ")" 1.  *p* = "", *q* = "())" 1.  *p* = "", *q* = ")()" 
In the second sample the only way to obtain a desired string is choose empty *p* and *q*.

In the third sample there is no way to get a valid sequence of brackets.
4 1
(
4
4 4
(())
1
4 3
(((
0
875 50
)))((())()))((()(())))))())))((((((()))))))()(((((
0
1980 464
))(()()))(((((((((()))))))(()(((()((()))()()())()))()))(()))))))(())((())))()())()((())())()())))(())()(()))(()())()((((()))())()(())))))(()()(()(((((()(()()))(((()))(())))))()())(())))))())()()((())))))))((()(())))))()()(()((()((()()))(()))(())(()))()((((())()()))))))()(())))()(()())()())(((((()))())))())())(()))()(()))())((())((((()(()(())))(((()()))))()()()))))((()())()((())())))())))()(()(()()(((((()((((()))()(())()))))()(()))(()(((((((()((()(())))(((((())
854368836
1542 282
())())()((()(()))()((())()))((())(()))))(()()))(())((()))()((()())())()))((())(((()(())((()()())((((())))((()((((()(()()))))(()(()()(())()((())())())))))()()())))(()((((()))(()(()(()(()))())((()()()()(()(()))())(((()(())()(())()()())))()))())(()))(((())()))((())()(())))))(())))()()
631927032
2 2
)(
0
2 2
))
0
class FamilyDoors():
    def __init__(self, n, m, s):
        self.n, self.m, self.s = n, m, s

    def balances(self):
        lb, rb = 0, 0
        os = 0
        for i in range(len(self.s)):
            if self.s[i] == '(':
                os += 1
            elif os == 0:
                lb += 1
            else:
                os -= 1

        oe = 0

        for i in range(len(self.s)-1, -1, -1):
            if self.s[i] == ')':
                oe += 1
            elif oe == 0:
                rb += 1
            else:
                oe -= 1

        return lb, rb

    def num_completions(self):
        l = self.n-self.m+1
        dp = [[0 for i in range(l)] for j in range(l)]

        p = 10**9 + 7

        dp[0][0] = 1

        for i in range(1, l):
            for j in range(i+1):
                if j == 0:
                    dp[i][j] = dp[i-1][j+1]
                elif j == i:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = (dp[i-1][j+1] + dp[i-1][j-1])%p

        print(dp)
        cnt = 0
        lb, rb = self.balances()
        print(lb, rb)

        for i in range(l):
            for j in range(lb, i+1):
                k = j-lb+rb
                if k < l:
                    cnt = (cnt + (dp[i][j]*dp[self.n-self.m-i][k])%p)%p

        return cnt



n, m = list(map(int,input().strip(' ').split(' ')))
s = input().strip()
print(FamilyDoors(n,m,s).num_completions())

