We start with a string $s$ consisting only of the digits $1$, $2$, or $3$. The length of $s$ is denoted by $|s|$. For each $i$ from $1$ to $|s|$, the $i$-th character of $s$ is denoted by $s_i$. 

There is one cursor. The cursor's location $\ell$ is denoted by an integer in $\{0, \ldots, |s|\}$, with the following meaning:   If $\ell = 0$, then the cursor is located before the first character of $s$.  If $\ell = |s|$, then the cursor is located right after the last character of $s$.  If $0 < \ell < |s|$, then the cursor is located between $s_\ell$ and $s_{\ell+1}$. 

We denote by $s_\text{left}$ the string to the left of the cursor and $s_\text{right}$ the string to the right of the cursor. 

We also have a string $c$, which we call our clipboard, which starts out as empty. There are three types of actions:  The Move action. Move the cursor one step to the right. This increments $\ell$ once.  The Cut action. Set $c \leftarrow s_\text{right}$, then set $s \leftarrow s_\text{left}$.  The Paste action. Append the value of $c$ to the end of the string $s$. Note that this doesn't modify $c$. 

The cursor initially starts at $\ell = 0$. Then, we perform the following procedure:  Perform the Move action once.  Perform the Cut action once.  Perform the Paste action $s_\ell$ times.  If $\ell = x$, stop. Otherwise, return to step 1. 

You're given the initial string $s$ and the integer $x$. What is the length of $s$ when the procedure stops? Since this value may be very large, only find it modulo $10^9 + 7$. 

It is guaranteed that $\ell \le |s|$ at any time.


-----Input-----

The first line of input contains a single integer $t$ ($1 \le t \le 1000$) denoting the number of test cases. The next lines contain descriptions of the test cases.

The first line of each test case contains a single integer $x$ ($1 \le x \le 10^6$). The second line of each test case consists of the initial string $s$ ($1 \le |s| \le 500$). It is guaranteed, that $s$ consists of the characters "1", "2", "3".

It is guaranteed that the sum of $x$ in a single file is at most $10^6$. It is guaranteed that in each test case before the procedure will stop it will be true that $\ell \le |s|$ at any time.


-----Output-----

For each test case, output a single line containing a single integer denoting the answer for that test case modulo $10^9 + 7$. 


-----Example-----
Input
4
5
231
7
2323
6
333
24
133321333

Output
25
1438
1101
686531475



-----Note-----

Let's illustrate what happens with the first test case. Initially, we have $s = $ 231. Initially, $\ell = 0$ and $c = \varepsilon$ (the empty string). The following things happen if we follow the procedure above:

  Step 1, Move once: we get $\ell = 1$.  Step 2, Cut once: we get $s = $ 2 and $c = $ 31.  Step 3, Paste $s_\ell = $ 2 times: we get $s = $ 23131.  Step 4: $\ell = 1 \not= x = 5$, so we return to step 1. 

  Step 1, Move once: we get $\ell = 2$.  Step 2, Cut once: we get $s = $ 23 and $c = $ 131.  Step 3, Paste $s_\ell = $ 3 times: we get $s = $ 23131131131.  Step 4: $\ell = 2 \not= x = 5$, so we return to step 1. 

  Step 1, Move once: we get $\ell = 3$.  Step 2, Cut once: we get $s = $ 231 and $c = $ 31131131.  Step 3, Paste $s_\ell = $ 1 time: we get $s = $ 23131131131.  Step 4: $\ell = 3 \not= x = 5$, so we return to step 1. 

  Step 1, Move once: we get $\ell = 4$.  Step 2, Cut once: we get $s = $ 2313 and $c = $ 1131131.  Step 3, Paste $s_\ell = $ 3 times: we get $s = $ 2313113113111311311131131.  Step 4: $\ell = 4 \not= x = 5$, so we return to step 1. 

  Step 1, Move once: we get $\ell = 5$.  Step 2, Cut once: we get $s = $ 23131 and $c = $ 13113111311311131131.  Step 3, Paste $s_\ell = $ 1 times: we get $s = $ 2313113113111311311131131.  Step 4: $\ell = 5 = x$, so we stop. 

At the end of the procedure, $s$ has length $25$.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "from collections import defaultdict as dc\n'''from collections import deque as dq\nfrom bisect import bisect_left,bisect_right,insort_left'''\nimport sys\nimport math\n#define of c++ as inl=input()\nmod=10**9 +7\ndef bs(a,x):\n    i=bisect_left(a,x)\n    if i!=len(a):\n        return i\n    else:\n        return len(a)\ndef bs(a,b):\n    l=a\n    r=b+1\n    x=b\n    ans=0\n    while(l<r):\n        mid=(l+r)//2\n        if x|mid>ans:\n            ans=x|mid\n            l=mid+1\n        else:\n            r=mid\n    return ans\ndef digit(n):\n    a=[]\n    while(n>0):\n        a.append(n%10)\n        n=n//10\n    return a\ndef inp():\n    p=int(input())\n    return p\ndef line():\n    p=list(map(int,input().split()))\n    return p\ndef ans(a,p,z,t):\n    q=[]\n    for i in range(len(a)):\n        if p[a[i]]==t and z>0 and p[a[i][::-1]]==0:\n            q.append(i+1)\n            z=z-1\n    return q\n            \nfor i in range(inp()):\n    x=inp()\n    s=str(input())\n    n=len(s)\n    p=n\n    for i in range(1,x+1):\n        if s[i-1]!='1':\n            p=(p%mod+((p-i)%mod * (int(s[i-1])-1)%mod)%mod)%mod\n            if len(s)<x:\n                z=s[i:]\n                s=s+z*(int(s[i-1])-1)\n    print(p)"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 14765