You have a string s of length n consisting of only characters > and <. You may do some operations with this string, for each operation you have to choose some character that still remains in the string. If you choose a character >, the character that comes right after it is deleted (if the character you chose was the last one, nothing happens). If you choose a character <, the character that comes right before it is deleted (if the character you chose was the first one, nothing happens).

For example, if we choose character > in string > > < >, the string will become to > > >. And if we choose character < in string > <, the string will become to <.

The string is good if there is a sequence of operations such that after performing it only one character will remain in the string. For example, the strings >, > > are good. 

Before applying the operations, you may remove any number of characters from the given string (possibly none, possibly up to n - 1, but not the whole string). You need to calculate the minimum number of characters to be deleted from string s so that it becomes good.

Input

The first line contains one integer t (1 ≤ t ≤ 100) – the number of test cases. Each test case is represented by two lines.

The first line of i-th test case contains one integer n (1 ≤ n ≤ 100) – the length of string s.

The second line of i-th test case contains string s, consisting of only characters > and <.

Output

For each test case print one line.

For i-th test case print the minimum number of characters to be deleted from string s so that it becomes good.

Example

Input


3
2
&lt;&gt;
3
&gt;&lt;&lt;
1
&gt;


Output


1
0
0

Note

In the first test case we can delete any character in string <>.

In the second test case we don't need to delete any characters. The string > < < is good, because we can perform the following sequence of operations: > < < → < < → <.
import java.util.Scanner;


public class Solution1 {
    
    
    public static int solve(String str,int len)
    {
        int[]sum=new int[len+1];
        int dp[][]=new int[len+1][3];
        //make prefix and a dp 
        int val=0;
        int ans=0;
        dp[0][0]=1;
        for(int i=1;i<=len;i++)
        {
            int dig=str.charAt(i-1)-'0';
            val+=dig;
            val%=3;
            sum[i]=val;
            
            dp[i][0]=dp[i-1][0];
            dp[i][1]=dp[i-1][1];
            dp[i][2]=dp[i-1][2];
            dp[i][sum[i]]++;
        }
        //look for single digits div by 8 but not 3
        for(int i=1;i<=len;i++)
        {
            int dig=str.charAt(i-1)-'0';
            if(dig==8)
                ans++;
            if(i-2>=0)
            {
                
                int pdig=str.charAt(i-2)-48;
                int number=pdig*10+dig;
                
                if(number%8==0 && number%3!=0)
                    ans++;
                
                
            }
            if(i-3>=0)
            {
                int pdig=str.charAt(i-2)-48;
                int prevdig=str.charAt(i-3)-48;
                int number=prevdig*100+pdig*10+dig;
                
                if(number%8!=0)
                    continue;
                else
                    {
                    ans+=(i-2);
                    ans-=dp[i-3][sum[i]];
                    }
            }
            }
        
        return ans;
    }
    
    public static void main(String args[])
    {
        Scanner s= new Scanner(System.in);
        int t=s.nextInt();
        while(t-->0)
        {
            int n=s.nextInt();
            String str=s.next();
            int ans=0;
            for(int i=0;i<n;i++)
            {
                if(str.charAt(i)=='>' || str.charAt(n-1-i)=='<')
                    {
                    ans=i;
                    break;
                    }
            }
            
            System.out.println(ans);
            
        }
    
    
    
    
    }
}

