description: There is a chessboard of size n by n. The square in the i-th row from top and j-th column from the left is labelled (i,j).
  
  Currently, Gregor has some pawns in the n-th row. There are also enemy pawns in the 1-st row. On one turn, Gregor moves one of his pawns. A pawn can move one square up (from (i,j) to (i-1,j)) if there is no pawn in the destination square. Additionally, a pawn can move one square diagonally up (from (i,j) to either (i-1,j-1) or (i-1,j+1)) if and only if there is an enemy pawn in that square. The enemy pawn is also removed.
  
  Gregor wants to know what is the maximum number of his pawns that can reach row 1?
  
  Note that only Gregor takes turns in this game, and the enemy pawns never move. Also, when Gregor's pawn reaches row 1, it is stuck and cannot make any further moves.
  
  Input
  
  The first line of the input contains one integer t (1≤ t≤ 2⋅ 10^4) — the number of test cases. Then t test cases follow.
  
  Each test case consists of three lines. The first line contains a single integer n (2≤ n≤ 2⋅{10}^{5}) — the size of the chessboard.
  
  The second line consists of a string of binary digits of length n, where a 1 in the i-th position corresponds to an enemy pawn in the i-th cell from the left, and 0 corresponds to an empty cell.
  
  The third line consists of a string of binary digits of length n, where a 1 in the i-th position corresponds to a Gregor's pawn in the i-th cell from the left, and 0 corresponds to an empty cell.
  
  It is guaranteed that the sum of n across all test cases is less than 2⋅{10}^{5}.
  
  Output
  
  For each test case, print one integer: the maximum number of Gregor's pawns which can reach the 1-st row.
  
  Example
  
  Input
  
  
  4
  3
  000
  111
  4
  1111
  1111
  3
  010
  010
  5
  11001
  00000
  
  
  Output
  
  
  3
  4
  0
  0
  
  Note
  
  In the first example, Gregor can simply advance all 3 of his pawns forward. Thus, the answer is 3.
  
  In the second example, Gregor can guarantee that all 4 of his pawns reach the enemy row, by following the colored paths as demonstrated in the diagram below. Remember, only Gregor takes turns in this "game"!
  
  <image>
  
  In the third example, Gregor's only pawn is stuck behind the enemy pawn, and cannot reach the end.
  
  In the fourth example, Gregor has no pawns, so the answer is clearly 0.
solution: # ---------------------------iye ha aam zindegi---------------------------------------------
  import math
  import random
  import heapq, bisect
  import sys
  from collections import deque, defaultdict
  from fractions import Fraction
  import sys
  from collections import defaultdict
  mod = 10 ** 9 + 7
  mod1 = 998244353
  
  # ------------------------------warmup----------------------------
  import os
  import sys
  from io import BytesIO, IOBase
  
  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")
  
  
  # -------------------game starts now----------------------------------------------------import math
  class TreeNode:
      def __init__(self, k, v):
          self.key = k
          self.value = v
          self.left = None
          self.right = None
          self.parent = None
          self.height = 1
          self.num_left = 1
          self.num_total = 1
  
  
  class AvlTree:
  
      def __init__(self):
          self._tree = None
  
      def add(self, k, v):
          if not self._tree:
              self._tree = TreeNode(k, v)
              return
          node = self._add(k, v)
          if node:
              self._rebalance(node)
  
      def _add(self, k, v):
          node = self._tree
          while node:
              if k < node.key:
                  if node.left:
                      node = node.left
                  else:
                      node.left = TreeNode(k, v)
                      node.left.parent = node
                      return node.left
              elif node.key < k:
                  if node.right:
                      node = node.right
                  else:
                      node.right = TreeNode(k, v)
                      node.right.parent = node
                      return node.right
              else:
                  node.value = v
                  return
  
      @staticmethod
      def get_height(x):
          return x.height if x else 0
  
      @staticmethod
      def get_num_total(x):
          return x.num_total if x else 0
  
      def _rebalance(self, node):
  
          n = node
          while n:
              lh = self.get_height(n.left)
              rh = self.get_height(n.right)
              n.height = max(lh, rh) + 1
              balance_factor = lh - rh
              n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
              n.num_left = 1 + self.get_num_total(n.left)
  
              if balance_factor > 1:
                  if self.get_height(n.left.left) < self.get_height(n.left.right):
                      self._rotate_left(n.left)
                  self._rotate_right(n)
              elif balance_factor < -1:
                  if self.get_height(n.right.right) < self.get_height(n.right.left):
                      self._rotate_right(n.right)
                  self._rotate_left(n)
              else:
                  n = n.parent
  
      def _remove_one(self, node):
          """
          Side effect!!! Changes node. Node should have exactly one child
          """
          replacement = node.left or node.right
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = replacement
              else:
                  node.parent.right = replacement
              replacement.parent = node.parent
              node.parent = None
          else:
              self._tree = replacement
              replacement.parent = None
          node.left = None
          node.right = None
          node.parent = None
          self._rebalance(replacement)
  
      def _remove_leaf(self, node):
          if node.parent:
              if AvlTree._is_left(node):
                  node.parent.left = None
              else:
                  node.parent.right = None
              self._rebalance(node.parent)
          else:
              self._tree = None
          node.parent = None
          node.left = None
          node.right = None
  
      def remove(self, k):
          node = self._get_node(k)
          if not node:
              return
          if AvlTree._is_leaf(node):
              self._remove_leaf(node)
              return
          if node.left and node.right:
              nxt = AvlTree._get_next(node)
              node.key = nxt.key
              node.value = nxt.value
              if self._is_leaf(nxt):
                  self._remove_leaf(nxt)
              else:
                  self._remove_one(nxt)
              self._rebalance(node)
          else:
              self._remove_one(node)
  
      def get(self, k):
          node = self._get_node(k)
          return node.value if node else -1
  
      def _get_node(self, k):
          if not self._tree:
              return None
          node = self._tree
          while node:
              if k < node.key:
                  node = node.left
              elif node.key < k:
                  node = node.right
              else:
                  return node
          return None
  
      def get_at(self, pos):
          x = pos + 1
          node = self._tree
          while node:
              if x < node.num_left:
                  node = node.left
              elif node.num_left < x:
                  x -= node.num_left
                  node = node.right
              else:
                  return (node.key, node.value)
          raise IndexError("Out of ranges")
  
      @staticmethod
      def _is_left(node):
          return node.parent.left and node.parent.left == node
  
      @staticmethod
      def _is_leaf(node):
          return node.left is None and node.right is None
  
      def _rotate_right(self, node):
          if not node.parent:
              self._tree = node.left
              node.left.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.left
              node.left.parent = node.parent
          else:
              node.parent.right = node.left
              node.left.parent = node.parent
          bk = node.left.right
          node.left.right = node
          node.parent = node.left
          node.left = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      def _rotate_left(self, node):
          if not node.parent:
              self._tree = node.right
              node.right.parent = None
          elif AvlTree._is_left(node):
              node.parent.left = node.right
              node.right.parent = node.parent
          else:
              node.parent.right = node.right
              node.right.parent = node.parent
          bk = node.right.left
          node.right.left = node
          node.parent = node.right
          node.right = bk
          if bk:
              bk.parent = node
          node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
          node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
          node.num_left = 1 + self.get_num_total(node.left)
  
      @staticmethod
      def _get_next(node):
          if not node.right:
              return node.parent
          n = node.right
          while n.left:
              n = n.left
          return n
  
  
  # -----------------------------------------------binary seacrh tree---------------------------------------
  class SegmentTree1:
      def __init__(self, data, default=2**51, func=lambda a, b: a & b):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------game starts now----------------------------------------------------import math
  class SegmentTree:
      def __init__(self, data, default=0, func=lambda a, b: a + b):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len - 1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size + self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i + i], self.data[i + i + 1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx + self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # -------------------------------iye ha chutiya zindegi-------------------------------------
  class Factorial:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorials = [1, 1]
          self.invModulos = [0, 1]
          self.invFactorial_ = [1, 1]
  
      def calc(self, n):
          if n <= -1:
              print("Invalid argument to calculate n!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.factorials):
              return self.factorials[n]
          nextArr = [0] * (n + 1 - len(self.factorials))
          initialI = len(self.factorials)
          prev = self.factorials[-1]
          m = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = prev * i % m
          self.factorials += nextArr
          return self.factorials[n]
  
      def inv(self, n):
          if n <= -1:
              print("Invalid argument to calculate n^(-1)")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          p = self.MOD
          pi = n % p
          if pi < len(self.invModulos):
              return self.invModulos[pi]
          nextArr = [0] * (n + 1 - len(self.invModulos))
          initialI = len(self.invModulos)
          for i in range(initialI, min(p, n + 1)):
              next = -self.invModulos[p % i] * (p // i) % p
              self.invModulos.append(next)
          return self.invModulos[pi]
  
      def invFactorial(self, n):
          if n <= -1:
              print("Invalid argument to calculate (n^(-1))!")
              print("n must be non-negative value. But the argument was " + str(n))
              exit()
          if n < len(self.invFactorial_):
              return self.invFactorial_[n]
          self.inv(n)  # To make sure already calculated n^-1
          nextArr = [0] * (n + 1 - len(self.invFactorial_))
          initialI = len(self.invFactorial_)
          prev = self.invFactorial_[-1]
          p = self.MOD
          for i in range(initialI, n + 1):
              prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
          self.invFactorial_ += nextArr
          return self.invFactorial_[n]
  
  
  class Combination:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorial = Factorial(MOD)
  
      def ncr(self, n, k):
          if k < 0 or n < k:
              return 0
          k = min(k, n - k)
          f = self.factorial
          return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
  
  
  # --------------------------------------iye ha combinations ka zindegi---------------------------------
  def powm(a, n, m):
      if a == 1 or n == 0:
          return 1
      if n % 2 == 0:
          s = powm(a, n // 2, m)
          return s * s % m
      else:
          return a * powm(a, n - 1, m) % m
  
  
  # --------------------------------------iye ha power ka zindegi---------------------------------
  def sort_list(list1, list2):
      zipped_pairs = zip(list2, list1)
  
      z = [x for _, x in sorted(zipped_pairs)]
  
      return z
  
  
  # --------------------------------------------------product----------------------------------------
  def product(l):
      por = 1
      for i in range(len(l)):
          por *= l[i]
      return por
  
  
  # --------------------------------------------------binary----------------------------------------
  def binarySearchCount(arr, n, key):
      left = 0
      right = n - 1
  
      count = 0
  
      while (left <= right):
          mid = int((right + left) / 2)
  
          # Check if middle element is
          # less than or equal to key
          if (arr[mid] < key):
              count = mid + 1
              left = mid + 1
  
          # If key is smaller, ignore right half
          else:
              right = mid - 1
  
      return count
  
  
  # --------------------------------------------------binary----------------------------------------
  def countdig(n):
      c = 0
      while (n > 0):
          n //= 10
          c += 1
      return c
  def binary(x, length):
      y = bin(x)[2:]
      return y if len(y) >= length else "0" * (length - len(y)) + y
  
  def countGreater(arr, n, k):
      l = 0
      r = n - 1
  
      # Stores the index of the left most element
      # from the array which is greater than k
      leftGreater = n
  
      # Finds number of elements greater than k
      while (l <= r):
          m = int(l + (r - l) / 2)
          if (arr[m] >= k):
              leftGreater = m
              r = m - 1
  
          # If mid element is less than
          # or equal to k update l
          else:
              l = m + 1
  
      # Return the count of elements
      # greater than k
      return (n - leftGreater)
  
  
  # --------------------------------------------------binary------------------------------------
  for ik in range(int(input())):
      n=int(input())
      a=list(input())
      b=list(input())
      ans=0
      for i in range(n):
          if b[i]=='1':
              if a[i]=='0':
                  ans+=1
              else:
                  if i>0 and a[i-1]=='1':
                      a[i-1]='0'
                      ans+=1
                  else:
                      if i<n-1 and a[i+1]=='1':
                          a[i+1]='0'
                          ans+=1
      print(ans)