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 os
  import sys
  from io import BytesIO, IOBase
  from collections import Counter
  import math as mt
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  
  
  def gcd(a, b):
      if a == 0:
          return b
      return gcd(b % a, a)
  
  
  def lcm(a, b):
      return (a * b) / gcd(a, b)
  
  
  mod = int(1e9) + 7
  
  
  def power(k, n):
      if n == 0:
          return 1
      if n % 2:
          return (power(k, n - 1) * k) % mod
      t = power(k, n // 2)
      return (t * t) % mod
  
  
  def totalPrimeFactors(n):
      count = 0
      if (n % 2) == 0:
          count += 1
          while (n % 2) == 0:
              n //= 2
  
      i = 3
      while i * i <= n:
          if (n % i) == 0:
              count += 1
              while (n % i) == 0:
                  n //= i
          i += 2
      if n > 2:
          count += 1
      return count
  
  
  # #MAXN = int(1e7 + 1)
  # # spf = [0 for i in range(MAXN)]
  #
  #
  # def sieve():
  #     spf[1] = 1
  #     for i in range(2, MAXN):
  #         spf[i] = i
  #     for i in range(4, MAXN, 2):
  #         spf[i] = 2
  #
  #     for i in range(3, mt.ceil(mt.sqrt(MAXN))):
  #         if (spf[i] == i):
  #             for j in range(i * i, MAXN, i):
  #                 if (spf[j] == j):
  #                     spf[j] = i
  #
  #
  # def getFactorization(x):
  #     ret = 0
  #     while (x != 1):
  #         k = spf[x]
  #         ret += 1
  #         # ret.add(spf[x])
  #         while x % k == 0:
  #             x //= k
  #
  #     return ret
  
  
  # Driver code
  
  # precalculating Smallest Prime Factor
  # sieve()
  
  def main():
      for _ in range(int(input())):
          n=int(input())
          f = input()
          s = input()
          ans = 0
          pre = [0, 0]
  
          for i in range(n):
              #print(s[i], f[i], pre)
              if ord('0') <= ord(s[i]) <= ord('1'):
                  if s[i] != f[i]:
                      ans += 2
                      for j in range(2):
                          if pre[j] == 0:
                              ans += j
                              break
                      pre = [0, 0]
                  else:
                      if s[i] == '0':
                          if pre[0]:
                              ans += 1
                          else:
                              pre[0] = 1
                              if pre[0]==pre[1]:
                                  ans+=2
                                  pre=[0, 0]
                      else:
                          if pre[0]:
                              ans += 2
                              pre = [0, 0]
                          else:
                              pre[1] = 1
          for j in range(2):
              if pre[j] == 0:
                  ans += j
                  break
          print(ans)
  
      return
  
  
  if __name__ == "__main__":
      main()
  