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
  import math
  from queue import Queue
  import collections
  import itertools
  import bisect
  import heapq
  # sys.setrecursionlimit(100000)
  # ^^^TAKE CARE FOR MEMORY LIMIT^^^
  import random
  
  
  def main():
      pass
  
  
  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)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  def binary(n):
      return (bin(n).replace("0b", ""))
  
  
  def decimal(s):
      return (int(s, 2))
  
  
  def pow2(n):
      p = 0
      while (n > 1):
          n //= 2
          p += 1
      return (p)
  
  
  def primeFactors(n):
      cnt = []
      while n % 2 == 0:
          cnt.append(2)
          n = n / 2
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              cnt.append(i)
              n = n / i
      if n > 2:
          cnt.append(int(n))
      return (cnt)
  
  def primeFactorsCount(n):
      cnt=0
      while n % 2 == 0:
          cnt+=1
          n = n // 2
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              cnt+=1
              n = n // i
      if n > 2:
          cnt+=1
      return (cnt)
  
  def isPrime(n):
      if (n == 1):
          return (False)
      else:
          root = int(n ** 0.5)
          root += 1
          for i in range(2, root):
              if (n % i == 0):
                  return (False)
          return (True)
  
  
  def maxPrimeFactors(n):
      maxPrime = -1
      while n % 2 == 0:
          maxPrime = 2
          n >>= 1
      for i in range(3, int(math.sqrt(n)) + 1, 2):
          while n % i == 0:
              maxPrime = i
              n = n / i
      if n > 2:
          maxPrime = n
      return int(maxPrime)
  
  
  def countcon(s, i):
      c = 0
      ch = s[i]
      for i in range(i, len(s)):
          if (s[i] == ch):
              c += 1
          else:
              break
      return (c)
  
  
  def lis(arr):
      n = len(arr)
      lis = [1] * n
      for i in range(1, n):
          for j in range(0, i):
              if arr[i] > arr[j] and lis[i] < lis[j] + 1:
                  lis[i] = lis[j] + 1
      maximum = 0
      for i in range(n):
          maximum = max(maximum, lis[i])
      return maximum
  
  
  def isSubSequence(str1, str2):
      m = len(str1)
      n = len(str2)
      j = 0
      i = 0
      while j < m and i < n:
          if str1[j] == str2[i]:
              j = j + 1
          i = i + 1
      return j == m
  
  
  def maxfac(n):
      root = int(n ** 0.5)
      for i in range(2, root + 1):
          if (n % i == 0):
              return (n // i)
      return (n)
  
  
  def p2(n):
      c = 0
      while (n % 2 == 0):
          n //= 2
          c += 1
      return c
  
  
  def seive(n):
      primes = [True] * (n + 1)
      primes[1] = primes[0] = False
      i = 2
      while (i * i <= n):
          if (primes[i] == True):
              for j in range(i * i, n + 1, i):
                  primes[j] = False
          i += 1
      pr = []
      for i in range(0, n + 1):
          if (primes[i]):
              pr.append(i)
      return pr
  
  
  def ncr(n, r, p):
      num = den = 1
      for i in range(r):
          num = (num * (n - i)) % p
          den = (den * (i + 1)) % p
      return (num * pow(den,
                        p - 2, p)) % p
  
  
  def denofactinverse(n, m):
      fac = 1
      for i in range(1, n + 1):
          fac = (fac * i) % m
      return (pow(fac, m - 2, m))
  
  
  def numofact(n, m):
      fac = 1
      for i in range(1, n + 1):
          fac = (fac * i) % m
      return (fac)
  
  def sod(n):
      s = 0
      while (n > 0):
          s += n % 10
          n //= 10
      return s
  def inv(n,m):
      return(pow(n,m-2,m))
  def countcon2(s1,s2,i):
      n=len(s1)
      cnt=0
      while(i<n and s1[i]==s2[i]):
          i+=1
          cnt+=1
      return cnt
  for xyz in range(0,int(input())):
      n=int(input())
      s1=input()
      s2=input()
      ans=0
      p="2"
      for i in range(0,n):
          #print(i,p)
          if(s1[i]!=s2[i]):
              ans+=2
              p="2"
          else:
              if(s1[i]=="0"):
                  ans+=1
                  #p="0"
                  if(p=="1"):
                      ans+=1
                      p="2"
                  else:
                      p="0"
              else:
                  if(p=="0"):
                      ans+=1
                      p="2"
                  else:
                      p="1"
      print(ans)