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: > < < → < < → <.
//package adalabq3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
//import java.util.Map;
import java.util.StringTokenizer;

public class Main {



	
	public static void main(String[] args)throws IOException
	{
		Reader.init(System.in);
		int t = Reader.nextInt();
		
		for( int i=0; i<t; i++)
		{
		int len = Reader.nextInt();
		String s = Reader.next();
//		System.out.println((int)s.charAt(0));
		
		if( (int)s.charAt(0)==62 || (int)s.charAt(len-1)==60)
		{
			System.out.println(0);
			
		}
		else if(len==2)
		{
			if((int)s.charAt(0)==60 && (int)s.charAt(1)==62)
				System.out.println(1);
			else
				System.out.println(0);
			
			
		}
		else
		{
			int min = Integer.MAX_VALUE;
			for( int j=0; j<len; j++)
			{
				if((int)s.charAt(j)==62)
				{
					if(j<min)
						min = j;
				}
			}
			for( int j=len-1; j>=0; j--)
			{
				if((int)s.charAt(j)==60)
				{
					if(len -1 - j<min)
					{
						min = len-1-j;
					
					}
				}
			}
			System.out.println(min);
		
		}
		}
}
}
class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }
    
    static long nextLong() throws IOException{
    	return Long.parseLong(next());
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
	
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}