description: 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.
solution: import sys,math,bisect
  # sys.setrecursionlimit(10**6)
  from random import randint
  inf = float('inf')
  mod = 10**9+7
  "========================================"
  def nCr(n, r):
      return (fact(n) / (fact(r)
                  * fact(n - r)))
  def fact(n):
      res = 1
      for i in range(2, n+1):
          res = res * i
      return res
  def lcm(a,b):
      return int((a/math.gcd(a,b))*b)
  def gcd(a,b):
      return int(math.gcd(a,b))
  def tobinary(n):
      return bin(n)[2:]
  def binarySearch(a,x):
      i = bisect.bisect_left(a,x)
      if i!=len(a) and a[i]==x:
          return i
      else:
          return -1
  def lowerBound(a, x):
      i = bisect.bisect_left(a, x)
      if i:
          return (i-1)
      else:
          return -1
  def upperBound(a,x):
      i = bisect.bisect_right(a,x)
      if i!= len(a)+1 and a[i-1]==x:
          return (i-1)
      else:
          return -1
  def primesInRange(n):
      ans = []
      prime = [True for i in range(n+1)]
      p = 2
      while (p * p <= n):
          if (prime[p] == True):
              for i in range(p * p, n+1, p):
                  prime[i] = False
          p += 1
      for p in range(2, n+1):
          if prime[p]:
              ans.append(p)
      return ans
  def primeFactors(n):
      factors = []
      while n % 2 == 0:
          factors.append(2)
          n = n // 2
      for i in range(3,int(math.sqrt(n))+1,2):
          while n % i== 0:
              factors.append(i)
              n = n // i
      if n > 2:
          factors.append(n)
      return factors
  def isPrime(n,k=5):
      if (n <2):
          return True
      for i in range(0,k):
          a = randint(1,n-1)
          if(pow(a,n-1,n)!=1):
              return False
      return True
  "========================================="
  """
  n = int(input())
  n,k = map(int,input().split())
  arr = list(map(int,input().split()))
  """
  from collections import deque,defaultdict,Counter
  from heapq import heappush, heappop,heapify
  import string
  
  
  for _ in range(int(input())):
      n=int(input())
      arr=input()
      brr=input()
      cnt = 0
      visited = [0]*n
      for i in range(n):
          if visited[i]:
              continue
          curr = [arr[i],brr[i]]
          if '0' in curr and '1' in curr:
              cnt+=2
              visited[i]=1
          else:
              canUse = True
              if i!=n-1:
                  next = [arr[i+1],brr[i+1]]
                  if '0' in next and '1' in next:
                      canUse = False
                  elif ('0' in curr and '1' in next) or ('1' in curr and '0' in next):
                      cnt+=2
                      visited[i]=1
                      visited[i+1]=1
                  else:
                      if '0' in curr:
                          cnt+=1
                          visited[i]=1
                  if not canUse and not visited[i]:
                      if '0' in curr:
                          cnt+=1
                      visited[i]=1
              else:
                  if '0' in curr:
                      cnt+=1
      print(cnt)
  