You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).

You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.

For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].

Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order.

Input

The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of test cases.

The first line of the test case contains a single integer n (3 ≤ n ≤ 50) — the number of elements in the permutation.

The second line of the test case contains n distinct integers from 1 to n — the given permutation a.

Output

For each test case, output a single integer — the minimum number of operations described above to sort the array a in ascending order.

Example

Input


3
4
1 3 2 4
3
1 2 3
5
2 1 4 5 3


Output


1
0
2

Note

In the explanations, a[i, j] defines the subarray of a that starts from the i-th element and ends with the j-th element.

In the first test case of the example, you can select the subarray a[2, 3] and swap the elements in it.

In the second test case of the example, the permutation is already sorted, so you don't need to apply any operations.

In the third test case of the example, you can select the subarray a[3, 5] and reorder the elements in it so a becomes [2, 1, 3, 4, 5], and then select the subarray a[1, 2] and swap the elements in it, so a becomes [1, 2, 3, 4, 5].
/*
                                "जय श्री कृष्णा"
*/
import java.util.*;
import java.io.*;

public class Main implements Runnable
{

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            this.br = new BufferedReader(new InputStreamReader(System.in));
        }
        public FastReader(String s)
        {
            try
            {
                this.br = new BufferedReader(new FileReader(s));
            }
            catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }

        int[] nextIntArray(int size)
        {
            int[] arr = new int[size];
            for (int i = 0; i < size; ++i)
                arr[i] = nextInt();
            return arr;
        }

        long[] nextLongArray(int size)
        {
            long[] arr = new long[size];
            for (int i = 0; i < size; ++i)
                arr[i] = nextLong();
            return arr;
        }

        double[] nextDoubleArray(int size)
        {
            double[] arr = new double[size];
            for (int i = 0; i < size; ++i)
                arr[i] = nextDouble();
            return arr;
        }
    }
    static class FastWriter
    {
        PrintWriter pw;

        public FastWriter()
        {
            this.pw = (new PrintWriter(new BufferedOutputStream(System.out)));
        }

        public FastWriter(String s)
        {
            try
            {
                this.pw = new PrintWriter(new File(s));
            }
            catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        public void print(Object object)
        {
            pw.append("" + object);
        }

        public void println(Object object)
        {
            print(object);
            pw.append("\n");
        }

        public void println()
        {
            pw.append("\n");
        }

        public void close()
        {
            pw.close();
        }

        public void flush()
        {
            pw.flush();
        }

    }


    static int mod = (int) (1e9 + 7), N = (int) (1e5), INF = Integer.MAX_VALUE, NINF = Integer.MIN_VALUE;
    static final FastReader fr = new FastReader();
    static final FastWriter out = new FastWriter();
    public static void main(String[] args) throws java.lang.Exception
    {
        new Thread(null, new Main(), "Main", 1 << 26).start();
    }


    void solve()
    {
        int n = fr.nextInt();
        int a[] = fr.nextIntArray(n);

        boolean check = true;

        for(int i = 0; i < n; ++i)
        {
            if(a[i] != (i + 1))
            {
                check = false;
                break;
            }
        }

        if(check)
        {
            out.print(0);
            return;
        }

        if(a[n - 1] == 1 && a[0] == n)
        {
            out.print(3);
            return;
        }

        out.print((a[0] == 1 || a[n - 1] == n) ? 1 : 2);

    }


    @Override
    public void run()
    {
        long start = System.nanoTime(); // Program Start
        boolean testcase = true;
        int t = testcase ? fr.nextInt() : 1;
        while (t-- > 0)
        {
            solve();
            out.print("\n");
            out.flush();
        }
        out.close();
        long end = System.nanoTime(); // Program End
    }

    static class CP
    {

        static boolean isPrime(long n)
        {
            if (n <= 1)
                return false;
            if (n == 2 || n == 3)
                return true;
            if (n % 2 == 0 || n % 3 == 0)
                return false;
            for (int i = 5; i * i <= n; i += 6)
            {
                if (n % i == 0 || n % (i + 2) == 0)
                    return false;
            }
            return true;
        }
        static List<Integer> sieve(int size)
        {
            ArrayList<Integer> pr = new ArrayList<Integer>();
            boolean prime[] = new boolean[size];
            for(int i = 2; i < prime.length; i++)  prime[i] = true;
            for(int i = 2; i * i < prime.length; i++)
            {
                if(prime[i])
                {
                    for(int j = i * i; j < prime.length; j += i)
                    {
                        prime[j] = false;
                    }
                }
            }
            for(int i = 2; i < prime.length; i++) if(prime[i]) pr.add(i);
            return pr;
        }

        static long binary_Expo(long a, long b)   // calculating a^b
        {
            long res = 1;
            while (b != 0)
            {
                if ((b & 1) == 1)
                {
                    res *= a;
                    --b;
                }
                a *= a;
                b /= 2;
            }
            return res;
        }

        static long Modular_Expo(long a, long b)
        {
            long res = 1;
            while (b != 0)
            {
                if ((b & 1) == 1)
                {
                    res = (res * a) % mod;
                    --b;
                }
                a = (a * a) % mod;
                b /= 2;
            }
            return res;
        }

        static int i_gcd(int a, int b)  // iterative way to calculate gcd.
        {
            while (true)
            {
                if (b == 0)
                    return a;
                int c = a;
                a = b;
                b = c % b;
            }
        }

        static long gcd(long a, long b)  // here b is the remainder
        {
            if (b == 0)
                return a; //because each time b will divide a.
            return gcd(b, a % b);
        }

        static long ceil_div(long a, long b)   // a numerator b denominator
        {
            return (a + b - 1) / b;
        }

        static int getIthBitFromInt(int bits, int i)
        {
            return (bits >> (i - 1)) & 1;
        }

        static int upper_Bound(int a[], int x)  //closest to the left+1
        {
            int l = -1, r = a.length;
            while (l + 1 < r)
            {
                int m = (l + r) >>> 1;
                if (a[m] <= x)
                    l = m;
                else
                    r = m;
            }
            return l + 1;
        }

        static int lower_Bound(int a[], int x)  //closest to the right
        {
            int l = -1, r = a.length;
            while (l + 1 < r)
            {
                int m = (l + r) >>> 1;
                if (a[m] >= x)
                    r = m;
                else
                    l = m;
            }
            return r;
        }
        static boolean isSquarefactor(int x, int factor, int target)
        {
            int s = (int)Math.round(Math.sqrt(x));
            return factor * s * s == target;
        }

        static boolean isSquare(int x)
        {
            int s = (int)Math.round(Math.sqrt(x));
            return x * x == s;
        }
        static void sort(int a[])
        {
            PriorityQueue<Integer> q = new PriorityQueue<>();
            for (int i = 0; i < a.length; i++)
                q.add(a[i]);
            for (int i = 0; i < a.length; i++)
                a[i] = q.poll();
        }

        static int getMax(int arr[], int n)
        {
            int mx = arr[0];
            for (int i = 1; i < n; i++)
                if (arr[i] > mx)
                    mx = arr[i];
            return mx;
        }
        static int[] z_function(String s)
        {
            int n = s.length(), z[] = new int[n];

            for(int i = 1, l = 0, r = 0; i < n; ++i)
            {
                if(i <= r)
                    z[i] = Math.min(z[i - l], r - i + 1);

                while(i + z[i] < n && s.charAt(z[i]) == s.charAt(i + z[i]))
                    ++z[i];

                if(i + z[i] - 1 > r)
                {
                    l = i;
                    r = i + z[i] - 1;
                }
            }
            return z;
        }
    }

}