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 java.util.*;
  import java.io.*;
  import java.lang.*;
  
  public class Main {
      //input
      static out op = new out();
      static inp ip = new inp();
      static FastReader sc = new FastReader();
      static BufferedWriter output = new BufferedWriter( 
          new OutputStreamWriter(System.out));
      static long inf = (long)1e9+7;
     
     static long mod = (long)1e18+7;
     static long z = 0;
  
     static void sol() throws Exception{
        
        int n = ip.in();
        char[] s1 = ip.cain();
        char[] s2 = ip.cain();
        
        int[] arr = new int[n];
        for(int i=0;i<n;i++)
           arr[i] = Integer.parseInt(s1[i]+"")*10+Integer.parseInt(s2[i]+"");
        
        int sum = 0;
        boolean shared[] = new boolean[n];
        for(int i=0;i<n;i++){
           if(arr[i] == 1)sum += 2;
           if(arr[i] == 10)sum += 2;
           
           if(arr[i] == 0){
              if(i+1<n && arr[i+1] == 11){
                 if(!shared[i]){
                    sum ++;
                    shared[i+1] = true;
                 }
              }
              sum += 1;
           }
           
           if(arr[i] == 11){
              if(i+1<n && arr[i+1] == 0){
                 if(!shared[i]){
                    sum++;
                    shared[i+1] = true;
                 }
              }
           }
        }
        
        op.sbln(sum);
        
     }
     
     
     static long gcd(long a,long b){
       if(b==0)
       return a;
       return gcd(b,a%b);
     }
     
     public static void main(String[] args) throws Exception { 
         
        int t = ip.in();
        while(t-- > 0){
           sol();
        }
        op.output.flush();
      }
     //  static class Node implements Comparable<Node>{
     //     int data;
     //     int ind;
     //    //  Node left,right;
     //    //  Node(){
     //    //       left = null;
     //    //       right = null;
     //    //  }
     //     Node(int ind,int data){
     //          this.data = data;
     //          this.ind = ind;
     //     }
      
     //       @Override
     //       public int compareTo(Node o) {
     //           if(this.data == o.data)
     //           return this.ind - o.ind;
     //           // TODO Auto-generated method stub
     //           return this.data - o.data;
     //       }
     //  }
  }
  
  
  class FastReader 
  { 
      BufferedReader br; 
      StringTokenizer st; 
  
      public FastReader() 
      { 
          br = new BufferedReader(new
                   InputStreamReader(System.in)); 
      } 
  
      String next() 
      { 
          while (st == null || !st.hasMoreElements()) 
          { 
              try
              { 
                  st = new StringTokenizer(br.readLine()); 
              } 
              catch (IOException  e) 
              { 
                  e.printStackTrace(); 
              } 
          } 
          return st.nextToken(); 
      } 
  
      int nextInt() 
      { 
          return Integer.parseInt(next()); 
      } 
  
      long nextLong() 
      { 
          return Long.parseLong(next()); 
      } 
  
      double nextDouble() 
      { 
          return Double.parseDouble(next()); 
      } 
  
      String nextLine() 
      { 
          String str = ""; 
          try
          { 
              str = br.readLine(); 
          } 
          catch (IOException e) 
          { 
              e.printStackTrace(); 
          } 
          return str; 
      }
  
  }
  class inp{
      FastReader sc = new FastReader();
      int in(){
          int a = sc.nextInt();
          return a;
      }
      long lin(){
          long a = sc.nextLong();
          return a;
      }
      char cin(){
          char c = sc.next().charAt(0);
          return c;
      }
      char[] cain(){
          char[] a = sc.nextLine().toCharArray();
          return a;
      }
      int[] arrin(int n){
          int [] arr = new int[n];
          for(int i=0;i<n;i++)
              arr[i] = in();
  
          return arr;
      }
      int[] mm_arr(int[] arr){
          int max = Integer.MIN_VALUE;
          int min = Integer.MAX_VALUE;
          for(int i=0;i<arr.length;i++){
              max = Math.max(max,arr[i]);
              min = Math.min(min,arr[i]);
          }
          int ans[] = {max,min};
          return ans;
      }
      int[] srt(int[] arr){
          Arrays.sort(arr);
          return arr;
      }
      long pow(long a,long b){
          if(b == 0)return 1;
          long res = pow(a,b/2);
          //System.out.println(res + " " + b + " " + (b&1));
          if((b&1) == 0)return res*res;
          return a*res*res; 
      }
  
     //  boolean[] prime(){
     //     boolean prime[] = new boolean[100000001];
     //     Arrays.fill(prime,true);
     //     for (int p = 2; p * p <= 10000000; p++)
     //     {
     //          // If prime[p] is not changed,
     //          // then it is a prime
     //          if (prime[p] == true)
     //          {
     //              // Update all multiples
     //              // of p greater than or
     //              // equal to the square of it
     //              // numbers which are multiple
     //              // of p and are less than p^2
     //              // are already been marked.
     //              for (int i = p * p; i <= 10000000; i += p)
     //                 prime[i] = false;
     //          }
     //     }
     //     return prime;
     //  }
  }
  class out{
      BufferedWriter output = new BufferedWriter( 
          new OutputStreamWriter(System.out)); 
  
      void sb(String s) throws IOException {
          output.write(s);
      }
      void sbln(Object s) throws IOException {
          output.write(s+"\n");
      }
      void yes() throws IOException{
          output.write("YES\n");
      }
      void no() throws IOException{
          output.write("NO\n");
      }
  }