description: Petya has got an interesting flower. Petya is a busy person, so he sometimes forgets to water it. You are given n days from Petya's live and you have to determine what happened with his flower in the end.
  
  The flower grows as follows: 
  
    * If the flower isn't watered for two days in a row, it dies. 
    * If the flower is watered in the i-th day, it grows by 1 centimeter. 
    * If the flower is watered in the i-th and in the (i-1)-th day (i > 1), then it grows by 5 centimeters instead of 1. 
    * If the flower is not watered in the i-th day, it does not grow. 
  
  
  
  At the beginning of the 1-st day the flower is 1 centimeter tall. What is its height after n days?
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
  
  The first line of each test case contains the only integer n (1 ≤ n ≤ 100).
  
  The second line of each test case contains n integers a_1, a_2, ..., a_n (a_i = 0 or a_i = 1). If a_i = 1, the flower is watered in the i-th day, otherwise it is not watered.
  
  Output
  
  For each test case print a single integer k — the flower's height after n days, or -1, if the flower dies.
  
  Example
  
  Input
  
  
  4
  3
  1 0 1
  3
  0 1 1
  4
  1 0 0 1
  1
  0
  
  
  Output
  
  
  3
  7
  -1
  1
solution: 
  import java.io.PrintWriter;
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.io.FileReader;
  import java.io.IOException;
  import java.util.StringTokenizer;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Arrays;
  import java.util.Stack;
  import java.util.HashSet;
  import java.util.TreeSet;
  import java.util.NavigableSet;
  import java.util.TreeMap;
  import java.util.Map;
  import java.util.PriorityQueue;
  import java.util.ArrayDeque;
  import static java.lang.Math.min;
  import static java.lang.Math.max;
  import static java.lang.Math.sqrt;
  import static java.lang.Math.pow;
  import static java.lang.Math.abs;
  import static java.lang.Integer.MIN_VALUE;
  import static java.lang.Integer.MAX_VALUE;
  
   
  public class Main { 
      
      static boolean ONLINE_JUDGE = false;
      static Fast f = new Fast();
      static PrintWriter out = new PrintWriter(System.out); 
      static boolean TEST_CASES = true;
      static int mod1 = (int)1e9+7;
      static int mod2 = 998244353;
      
      
      static void solve() {        
  
          int n = ri();
          int[] a = ra(n);
          int ans = 1;
          int count = 0;
          if(a[0]==1) ans++;
          else count++;
          for(int i = 1; i < n; i++) {
             if(a[i]==1) {
              count=0;
              if(a[i-1]==1) ans += 5;
              else ans++;
             }
             else count++;
  
             if(count==2) {ans=-1; break; } 
          }
  
          out.println(ans);
  
      }
  
  
      public static void main(String[] args)throws Exception{
  
  
        
        
        if(TEST_CASES){
            
            int t = ri();
            
            while(t-->0){
            
              solve();
            
            }
  
        }
  
        else {
  
          solve();
        
        }
        
        out.close();
  
      }
  
      
      static int nod(long l) {
         if(l>=1000000000000000000l) return 19;
         if(l>=100000000000000000l) return 18;
         if(l>=10000000000000000l) return 17;
         if(l>=1000000000000000l) return 16;
         if(l>=100000000000000l) return 15;
         if(l>=10000000000000l) return 14;
         if(l>=1000000000000l) return 13;
         if(l>=100000000000l) return 12;
         if(l>=10000000000l) return 11;
         if(l>=1000000000) return 10;
         if(l>=100000000) return 9;
         if(l>=10000000) return 8;
         if(l>=1000000) return 7;
         if(l>=100000) return 6;
         if(l>=10000) return 5;
         if(l>=1000) return 4;
         if(l>=100) return 3;
         if(l>=10) return 2;
         return 1;
      }
  
  
      static int ri() {
  
        return f.nextInt();
      
      }
  
      static long rl() {
   
        return f.nextLong();
      
      }
  
      static String rs(){
  
        return f.next();
  
      }
  
      static String rS(){
        
         return f.nextLine();
      
      }
  
      static char rc(){
  
           return f.next().charAt(0);
  
      }
  
      static int[] ra(int n) {
          
        int[] a = new int[n];
        for(int i = 0;i<n;i++) a[i] = ri();
        return a;
          
      }
  
      static long[] ral(int n) {
          
        long[] a = new long[n];
        for(int i = 0;i<n;i++) a[i] = rl();
        return a;
          
      }
  
      static char[] rac(){
  
          char[] c = rs().toCharArray();
  
          return c;
  
      }
      
      static int[][] rm(int n, int m){
         
         int[][] mat = new int[n][m];
  
         for(int i = 0; i < n; i++) mat[i] = ra(m);
         
         return mat;
  
      }
  
      static char[][] rmc(int n){
        
        char[][] cmat = new char[n][];
        
        for(int i = 0; i < n;i++) cmat[i] = rac();
  
        return cmat;
  
      }
  
      static void sort(int[] a) {
  
        ArrayList<Integer> list=new ArrayList<>();
        for (int i:a) list.add(i);
        Collections.sort(list);
        for (int i=0; i<a.length; i++) a[i]=list.get(i);
  
      }
  
      static void sort(double[] a) {
  
        ArrayList<Double> list=new ArrayList<>();
        for (double i:a) list.add(i);
        Collections.sort(list);
        for (int i=0; i<a.length; i++) a[i]=list.get(i);
  
      }
    
      static class Fast{
         public BufferedReader br;
         public StringTokenizer st;
         
         public Fast(){
              try{
                  br = ONLINE_JUDGE? (new BufferedReader(new FileReader("input.txt"))):(new BufferedReader(new InputStreamReader(System.in)));
              }
              catch(Exception e){
                throw new RuntimeException(e);
              }
         }
         
         String next(){
              while(st==null || !st.hasMoreTokens()){
                   try{
                        st=new StringTokenizer(br.readLine());
                   }
                   catch(IOException e){
                        throw new RuntimeException(e);
                   }
                   
              }
                   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; 
            } 
     
       }
  }
  
  
  
  