A binary string is a string that consists of characters 0 and 1. A bi-table is a table that has exactly two rows of equal length, each being a binary string.

Let \operatorname{MEX} of a bi-table be the smallest digit among 0, 1, or 2 that does not occur in the bi-table. For example, \operatorname{MEX} for \begin{bmatrix} 0011\\\ 1010 \end{bmatrix} is 2, because 0 and 1 occur in the bi-table at least once. \operatorname{MEX} for \begin{bmatrix} 111\\\ 111 \end{bmatrix} is 0, because 0 and 2 do not occur in the bi-table, and 0 < 2.

You are given a bi-table with n columns. You should cut it into any number of bi-tables (each consisting of consecutive columns) so that each column is in exactly one bi-table. It is possible to cut the bi-table into a single bi-table — the whole bi-table.

What is the maximal sum of \operatorname{MEX} of all resulting bi-tables can be?

Input

The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. Description of the test cases follows.

The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 10^5) — the number of columns in the bi-table.

Each of the next two lines contains a binary string of length n — the rows of the bi-table.

It's guaranteed that the sum of n over all test cases does not exceed 10^5.

Output

For each test case print a single integer — the maximal sum of \operatorname{MEX} of all bi-tables that it is possible to get by cutting the given bi-table optimally.

Example

Input


4
7
0101000
1101100
5
01100
10101
2
01
01
6
000000
111111


Output


8
8
2
12

Note

In the first test case you can cut the bi-table as follows:

  * \begin{bmatrix} 0\\\ 1 \end{bmatrix}, its \operatorname{MEX} is 2.
  * \begin{bmatrix} 10\\\ 10 \end{bmatrix}, its \operatorname{MEX} is 2.
  * \begin{bmatrix} 1\\\ 1 \end{bmatrix}, its \operatorname{MEX} is 0.
  * \begin{bmatrix} 0\\\ 1 \end{bmatrix}, its \operatorname{MEX} is 2.
  * \begin{bmatrix} 0\\\ 0 \end{bmatrix}, its \operatorname{MEX} is 1.
  * \begin{bmatrix} 0\\\ 0 \end{bmatrix}, its \operatorname{MEX} is 1.



The sum of \operatorname{MEX} is 8.
def main():
    alpha = 'abcdefghijklmnopqrstuvwxyz'
    ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    inf = 1e17
    mod = 10 ** 9 + 7

    # Max = 10 ** 1
    # primes = []
    # prime = [True for i in range(Max + 1)]
    # p = 2
    # while (p * p <= Max + 1):
    #
    #     # If prime[p] is not
    #     # changed, then it is a prime
    #     if (prime[p] == True):
    #
    #         # Update all multiples of p
    #         for i in range(p * p, Max + 1, p):
    #             prime[i] = False
    #     p += 1
    #
    # for p in range(2, Max + 1):
    #     if prime[p]:
    #         primes.append(p)
    #
    # print(primes)


    def factorial(n):
        f = 1

        for i in range(1, n + 1):
            f = (f * i) % mod  # Now f never can
        # exceed 10^9+7

        return f

    def ncr(n, r):
        # initialize numerator
        # and denominator
        num = den = 1
        for i in range(r):
            num = (num * (n - i)) % mod
            den = (den * (i + 1)) % mod
        return (num * pow(den,
                          mod - 2, mod)) % mod




    def mex(a,b):

        if a == '0' and b == '0':
            return 1
        elif a == '1' and b == '1':
            return 0
        else:
            return 2

    def solve(s1,s2):

        last_mex = mex(s1[0],s2[0])
        Sum = mex(s1[0],s2[0])
        for i in range(1,n):

            if last_mex == 0 and mex(s1[i],s2[i]) == 1:
                Sum += 2
                last_mex = 2
            elif last_mex == 1 and mex(s1[i],s2[i]) == 0:
                Sum += 1
                last_mex = 2
            else:
                Sum += mex(s1[i],s2[i])
                last_mex = mex(s1[i],s2[i])

        return Sum








    t = int(input())
    ans = []
    for _ in range(t):
        n = int(input())

        #n,s = map(int, input().split())
        s1 = input()[:-1]
        s2 = input()[:-1]
        #arr = [int(x) for x in input().split()]
        #b = [int(x) for x in input().split()]
        #arr = list(input())[:-1][::-1]
        ans.append(solve(s1,s2))

    p = 1
    for answer in ans:
        #print('Case #'+str(p)+": "+str(answer))
        print(answer)
        p += 1


if __name__ == "__main__":
    import sys, threading
    import bisect
    import math
    import itertools
    from sys import stdout


    ############  Sorted Containers  ######################
    import heapq
    from queue import PriorityQueue


    ############ Tree Problems ( Use Python 3) ###########
    #sys.setrecursionlimit(2 ** 32 // 2 - 1)
    #threading.stack_size(1 << 27)

    input = sys.stdin.readline
    thread = threading.Thread(target=main)
    thread.start()
    thread.join()