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: #DaRk DeveLopeR
  import sys
  
  
  #taking input as string 
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
  mod = 10**9+7; Mod = 998244353; INF = float('inf')
  #______________________________________________________________________________________________________
  import math
  from bisect import *
  from heapq import *
  from collections import defaultdict as dd
  from collections import OrderedDict as odict
  from collections import Counter as cc
  from collections import deque
  from itertools import groupby
  sys.setrecursionlimit(20*20*20*20+10) #this is must for dfs
  
  
  
  def solve():
  
  	n=takein()
  
  	string1=takesr()
  
  	string2=takesr()
  	ans=0
  	if "0" not in string1 and "0" not in string2:
  		ans=0
  	elif "1" not in string1 and "1" not in string2:
  		ans=1
  	else:
  		ans=2
  
  	index=0
  	count=0
  
  	while index<n:
  
  		if string1[index]!=string2[index]:
  
  			count+=2
  
  		else:
  
  			if string1[index]==string2[index]=="0":
  
  				if index+1<n:
  
  					if  string1[index+1]==string2[index+1]=="1" :
  
  							count+=2
  							index+=1
  					else:
  						count+=1
  
  
  				else:
  					count+=1
  
  			else:
  				# print("YES")
  				if index+1<n:
  
  					if string1[index+1]==string2[index+1]=="0" :
  
  							count+=2
  							index+=1
  
  		# print(count,index)
  		index+=1
  
  	print(max(count,ans))
  
  
  
  
  
  
  
  	
  
  
  
  
  def main():
      global tt
      if not ONLINE_JUDGE:
          sys.stdin = open("input.txt","r")
          sys.stdout = open("output.txt","w")
      t = 1
      t = takein()
      #t = 1
      for tt in range(1,t + 1):
          solve()
      if not ONLINE_JUDGE:
          print("Time Elapsed :",time.time() - start_time,"seconds")
          sys.stdout.close()
  
  #---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
  def takein():
      return (int(sys.stdin.readline().rstrip("\r\n")))
  
  
  # input the string
  
  def takesr():
      return (sys.stdin.readline().rstrip("\r\n"))
  
  
  # input int array
  def takeiar():
      return (list(map(int, sys.stdin.readline().rstrip("\r\n").split())))
  
  
  # input string array
  def takesar():
      return (list(map(str, sys.stdin.readline().rstrip("\r\n").split())))
  
  
  # innut values for the diffrent variables
  def takeivr():
      return (map(int, sys.stdin.readline().rstrip("\r\n").split()))
  
  
  def takesvr():
      return (map(str, sys.stdin.readline().rstrip("\r\n").split()))
  
   
   
  #------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
  
  
  
  def ispalindrome(s):
  
  	return s==s[::-1]
   
  def invert(bit_s):
  
  
  	  
  	# convert binary string 
  	# into integer
  	temp = int(bit_s, 2)
  	  
  	# applying Ex-or operator
  	# b/w 10 and 31
  	inverse_s = temp ^ (2 ** (len(bit_s) + 1) - 1)
  	  
  	# convert the integer result 
  	# into binary result and then 
  	# slicing of the '0b1' 
  	# binary indicator
  	rslt = bin(inverse_s)[3 : ]
  
  	return str(rslt) 	  
  
  def counter(a):
      q = [0] * max(a)
      for i in range(len(a)):
          q[a[i] - 1] = q[a[i] - 1] + 1
      return(q)
   
  def counter_elements(a):
      q = dict()
      for i in range(len(a)):
          if a[i] not in q:
              q[a[i]] = 0
          q[a[i]] = q[a[i]] + 1
      return(q)
   
  def string_counter(a):
      q = [0] * 26
      for i in range(len(a)):
          q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
      return(q)
   
  def factorial(n,m = 1000000007):
      q = 1
      for i in range(n):
          q = (q * (i + 1)) % m
      return(q)
   
  def factors(n):
      q = []
      for i in range(1,int(n ** 0.5) + 1):
          if n % i == 0: q.append(i); q.append(n // i)
      return(list(sorted(list(set(q)))))
   
  def prime_factors(n):
      q = []
      while n % 2 == 0: q.append(2); n = n // 2
      for i in range(3,int(n ** 0.5) + 1,2):
          while n % i == 0: q.append(i); n = n // i
      if n > 2: q.append(n)
      return(list(sorted(q)))
   
  def transpose(a):
      n,m = len(a),len(a[0])
      b = [[0] * n for i in range(m)]
      for i in range(m): 
          for j in range(n): 
              b[i][j] = a[j][i]
      return(b)
   
  def power_two(x):
      return (x and (not(x & (x - 1))))
   
  def ceil(a, b):
      return -(-a // b)
  
  
  
  def seive(n):
  	a = [1]
  	prime = [True for i in range(n+1)] 
  	p = 2
  	while (p * p <= n): 
  	    if (prime[p] == True): 
  	        for i in range(p ** 2,n + 1, p): 
  	            prime[i] = False
  	    p = p + 1
  	for p in range(2,n + 1): 
  	    if prime[p]: 
  	        a.append(p)
  	return(a)
  
   
  def pref(li):
      pref_sum = [0]
      for i in li:
          pref_sum.append(pref_sum[-1]+i)
      return pref_sum
   
  def kadane(x):  # maximum sum contiguous subarray
      sum_so_far = 0
      current_sum = 0
      for i in x:
          current_sum += i
          if current_sum < 0:
              current_sum = 0
          else:
              sum_so_far = max(sum_so_far, current_sum)
      return sum_so_far
  
  def binary_search(li, val):
      # print(lb, ub, li)
      ans = -1
      lb = 0
      ub = len(li)-1
      while (lb <= ub):
          mid = (lb+ub) // 2
          # print('mid is',mid, li[mid])
          if li[mid] > val:
              ub = mid-1
          elif val > li[mid]:
              lb = mid+1
          else:
              ans = mid  # return index
              break
      return ans
  
  
   
  def upper_bound(li, num):
      answer = -1
      start = 0
      end = len(li)-1
   
      while (start <= end):
          middle = (end+start) // 2
   
          if li[middle] <= num:
              answer = middle
              start = middle+1
   
          else:
              end = middle-1
      return answer  # max index where x is not greater than num
  
  
  def lower_bound(li, num):
      answer = -1
      start = 0
      end = len(li)-1
   
      while (start <= end):
          middle = (end+start) // 2
          if li[middle] >= num:
              answer = middle
              end = middle-1
          else:
              start = middle+1
      return answer  # min index where x is not less than num
  #-----------------------------------------------------------------------#
  ONLINE_JUDGE = __debug__
  if ONLINE_JUDGE:
      input = sys.stdin.readline
      
  main()