You are given the strings a and b, consisting of lowercase Latin letters. You can do any number of the following operations in any order: 

  * if |a| > 0 (the length of the string a is greater than zero), delete the first character of the string a, that is, replace a with a_2 a_3 … a_n; 
  * if |a| > 0, delete the last character of the string a, that is, replace a with a_1 a_2 … a_{n-1}; 
  * if |b| > 0 (the length of the string b is greater than zero), delete the first character of the string b, that is, replace b with b_2 b_3 … b_n; 
  * if |b| > 0, delete the last character of the string b, that is, replace b with b_1 b_2 … b_{n-1}. 



Note that after each of the operations, the string a or b may become empty.

For example, if a="hello" and b="icpc", then you can apply the following sequence of operations: 

  * delete the first character of the string a ⇒ a="ello" and b="icpc"; 
  * delete the first character of the string b ⇒ a="ello" and b="cpc"; 
  * delete the first character of the string b ⇒ a="ello" and b="pc"; 
  * delete the last character of the string a ⇒ a="ell" and b="pc"; 
  * delete the last character of the string b ⇒ a="ell" and b="p". 



For the given strings a and b, find the minimum number of operations for which you can make the strings a and b equal. Note that empty strings are also equal.

Input

The first line contains a single integer t (1 ≤ t ≤ 100). Then t test cases follow.

The first line of each test case contains the string a (1 ≤ |a| ≤ 20), consisting of lowercase Latin letters.

The second line of each test case contains the string b (1 ≤ |b| ≤ 20), consisting of lowercase Latin letters.

Output

For each test case, output the minimum number of operations that can make the strings a and b equal.

Example

Input


5
a
a
abcd
bc
hello
codeforces
hello
helo
dhjakjsnasjhfksafasd
adjsnasjhfksvdafdser


Output


0
2
13
3
20
import java.util.*;
import java.math.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class b{ 

     static FastScanner sc;
     static long[] arr;
     static long mul,mul1;
     static int[] spf;
     static int n,q;
     static long mod = ((long)(1e9))+7;

     static long[] st;
    static long[] lazy;

    static void func(int n) {
        st = new long[5 * n];
        lazy = new long[5 * n];
        for (int i = 0; i < 5* n; i++) {
            st[i] = 1;
            lazy[i] = 1;
        }
    }

    static void pushdown(int node, int ss, int se) {
        st[node] *= lazy[node];
        if (ss != se) {
            lazy[2 * node + 1] *= lazy[node];
            lazy[2 * node + 2] *= lazy[node];
        }
        lazy[node] = 1;

    }

    static void update(int node, int ss, int se, int l, int r, int val) {
        pushdown(node, ss, se);
        // break condition
        if (se < l || ss > r) {
            return;
        }
        // tag condition
        if (ss >= l && se <= r) {
            lazy[node] = mod(lazy[node]*val,mod);
            pushdown(node, ss, se);
            return;
        }
        int mid = (ss + se) / 2;
        update(2 * node + 1, ss, mid, l, r, val);
        update(2 * node + 2, mid+1, se, l, r, val);
        st[node] = combine(st[2 * node + 1], st[2 * node + 2]);
    }

    static long combine(long a, long b) {
        if (b == 0) {
            return a;
        }
        return combine(b, a % b);
    }

    static long get(int node, int ss, int se, int l, int r) {
        pushdown(node, ss, se);
        if (se < l || ss > r) {
            return 1;
        }
        if (ss >= l && se <= r) {

            return st[node];
        }
        int mid = (ss + se) / 2;
        if(mid<l){
            return get(2*node+2, mid+1, se, l, r);
        }else if(mid+1>r){
            return get(2*node+1, ss, mid, l, r);
        }
        return combine(get(2 * node + 1, ss, mid, l, r), get(2 * node + 2, mid + 1, se, l, r));
    }

    

    // public static void getFactorization(int x) 
    // { 
    //     // ArrayList<Integer> ret = new ArrayList<Integer>(); 
    //     mul = 1;
    //     mul1 = 1;
    //     int curr = 0;
    //     while (x != 1) 
    //     {      
    //         // System.out.println(spf[x]);
    //         int num = spf[x];
    //         // ret.add(num); 
    //         while(x%num == 0){
    //             x /= num;
    //             curr += 1;
    //         }
    //         if(curr%2 == 0)
    //             mul1 *= num;
    //         else
    //             mul *= num;
    //         curr = 0;
    //     } 
    //     // System.out.println(mul + " " + mul1);
    //     // System.out.println(mul);
    // } 

     public static void solve(char X[], char Y[],
                         int m, int n){

        int LCStuff[][] = new int[m + 1][n + 1];
        int result = 0;

        for (int i = 0; i <= m; i++)
        {
            for (int j = 0; j <= n; j++)
            {
                if (i == 0 || j == 0)
                    LCStuff[i][j] = 0;
                else if (X[i - 1] == Y[j - 1])
                {
                    LCStuff[i][j]
                        = LCStuff[i - 1][j - 1] + 1;
                    result = Integer.max(result,
                                         LCStuff[i][j]);
                }
                else
                    LCStuff[i][j] = 0;
            }
        }
        System.out.println(m + n - 2*result);


     }

        
     public static void main(String[] args) {

            sc = new FastScanner();
            // Scanner sc = new Scanner(System.in);
            int t = sc.nextInt();
            // int t = 1;
            while(t > 0){

                // n = sc.nextInt();
                // // q = sc.nextInt();
                // arr = new long[n];
                // for(int i = 0 ; i < n ; i++)
                //     arr[i] = sc.nextLong();
                char[] x = sc.next().toCharArray();
                char[] y = sc.next().toCharArray();
                solve(x,y,x.length,y.length);       
                t -= 1;
            }

     }

    // Use this instead of Arrays.sort() on an array of ints. Arrays.sort() is n^2
    // worst case since it uses a version of quicksort. Although this would never
    // actually show up in the real world, in codeforces, people can hack, so
    // this is needed.
    static void ruffleSort(long[] a) {
        //ruffle
        int n=a.length;
        Random r=new Random();
        for (int i=0; i<a.length; i++) {
            int oi=r.nextInt(n);long temp=a[i];
            a[i]=a[oi];
            a[oi]=temp;
        }
        
        //then sort
        Arrays.sort(a);
    }
    public static long gcd(long a, long b)
    {
      if (b == 0)
        return a;
      return gcd(b, a % b); 
    }
    public static long mod(long x, long mod)
{
    long result = x % mod;
    if (result < 0)
    {
        result += mod;
    }
    return result;
}

    static class Node{
            int s;
            int e;
            Node(int f,int s){
                this.s = f;
                this.e = s;
            }
        }
    
    // Use this to input code since it is faster than a Scanner
    static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }
        
        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }
}
 