description: A string is called square if it is some string written twice in a row. For example, the strings "aa", "abcabc", "abab" and "baabaa" are square. But the strings "aaa", "abaaab" and "abcdabc" are not square.
  
  For a given string s determine if it is square.
  
  Input
  
  The first line of input data contains an integer t (1 ≤ t ≤ 100) —the number of test cases.
  
  This is followed by t lines, each containing a description of one test case. The given strings consist only of lowercase Latin letters and have lengths between 1 and 100 inclusive.
  
  Output
  
  For each test case, output on a separate line:
  
    * YES if the string in the corresponding test case is square, 
    * NO otherwise. 
  
  
  
  You can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive response).
  
  Example
  
  Input
  
  
  10
  a
  aa
  aaa
  aaaa
  abab
  abcabc
  abacaba
  xxyy
  xyyx
  xyxy
  
  
  Output
  
  
  NO
  YES
  NO
  YES
  YES
  YES
  NO
  NO
  NO
  YES
solution:     import java.io.*;
      import java.util.*;
      import java.math.*;
      import java.lang.*;
       
  
  
  
       //@Manan Parmar
      public class Solution2 implements Runnable {
          public void run() {
              
          InputReader sc = new InputReader(System.in);
          PrintWriter out = new PrintWriter(System.out);
          
          
          //code
          
  
          int t1=sc.nextInt();
          while(t1--!=0)
          {
              String s=sc.next();
              if(s.length()%2!=0)
                  out.println("NO");
              else
              {
                  //out.println(s.substring((s.length()/2),s.length()));
                  if(s.substring(0,(s.length()/2)).equals(s.substring((s.length()/2),s.length())))
                      out.println("YES");
                  else
                      out.println("NO");
              }
          }
  
  
  
          out.close();
          }
      
      /*class pairComparator implements Comparator<Pair>
          {
              public int compare(Pair p1,Pair p2)
              {
                  return p1.a-p2.a;
              }
          }
              class Pair{
              int id;
              int a;
  
              public Pair(int id,int a)
              {
                  this.id=id;
                  this.a=a;
              }   
          }*/
        
       
  
      //========================================================================
          int lcsLength(String s1,String s2)
          {
              int x=s1.length(),y=s2.length();
              int dp[][]=new int[x+1][y+1];
              for(int i=1;i<=x;i++)
              {
                  for(int j=1;j<=y;j++)
                  {
                      if(s1.charAt(i-1)==s2.charAt(j-1))
                      {
                          dp[i][j]=1+dp[i-1][j-1];
                      }
                      else
                      {
                          dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                      }
                  }
              }
              return dp[x][y];
          }
          String lcs(String s1,String s2)
          {
              int x=s1.length(),y=s2.length();
              int dp[][]=new int[x+1][y+1];
              for(int i=1;i<=x;i++)
              {
                  for(int j=1;j<=y;j++)
                  {
                      if(s1.charAt(i-1)==s2.charAt(j-1))
                      {
                          dp[i][j]=1+dp[i-1][j-1];
                      }
                      else
                      {
                          dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
                      }
                  }
              }
             
              int index = dp[x][y];
              int temp = index;
         
              // Create a character array to store the lcs string
              char[] lcs = new char[index+1];
              lcs[index] = '\u0000'; // Set the terminating character
         
              // Start from the right-most-bottom-most corner and
              // one by one store characters in lcs[]
              int i = x;
              int j = y;
              while (i > 0 && j > 0)
              {
                  // If current character in X[] and Y are same, then
                  // current character is part of LCS
                  if (s1.charAt(i-1) == s2.charAt(j-1))
                  {
                      // Put current character in result
                      lcs[index-1] = s1.charAt(i-1); 
                        
                      // reduce values of i, j and index
                      i--; 
                      j--; 
                      index--;     
                  }
         
                  // If not same, then find the larger of two and
                  // go in the direction of larger value
                  else if (dp[i-1][j] > dp[i][j-1])
                      i--;
                  else
                      j--;
              }
         
              // Print the lcs
              String ans="";
              for(int k=0;k<=temp;k++)
                  ans=ans+Character.toString(lcs[k]);
              return ans;
  
          }
          int gcd(int a, int b)
          {
            if (b == 0)
              return a;
            return gcd(b, a % b);
          }
          boolean isPrime(int n) 
          { 
              // Corner case 
              if (n <= 1) 
                  return false; 
        
              // Check from 2 to n-1 
              for (int i = 2; i < n; i++) 
                  if (n % i == 0) 
                      return false; 
        
              return true; 
          } 
          int lcm(int number1, int number2) {
              if (number1 == 0 || number2 == 0) {
                  return 0;
              }
              int absNumber1 = Math.abs(number1);
              int absNumber2 = Math.abs(number2);
              int absHigherNumber = Math.max(absNumber1, absNumber2);
              int absLowerNumber = Math.min(absNumber1, absNumber2);
              int lcm = absHigherNumber;
              while (lcm % absLowerNumber != 0) {
                  lcm += absHigherNumber;
              }
              return lcm;
          }
          void quickSort(int a[],int l,int r)
          {
              if(l<r)
              {
                  int pindex=partition(a,l,r);
                  quickSort(a,l,pindex-1);
                  quickSort(a,pindex+1,r);
              }
  
          }
          int partition(int a[],int l,int r)
          {
              int pivot = a[r],pindex=l;
              for(int i=l;i<r;i++)
              {
                  if(a[i]<pivot)
                  {
                      int temp=a[i];
                      a[i]=a[pindex];
                      a[pindex]=temp;
                      pindex++;
                  }
              }
              int temp1=a[r];
              a[r]=a[pindex];
              a[pindex]=temp1;
              return pindex;
          }
          int binarySearch(int arr[], int x) 
          { 
              int l = 0, r = arr.length - 1; 
              while (l <= r) { 
                  int m = l + (r - l) / 2; 
        
                  // Check if x is present at mid 
                  if (arr[m] >= x)
                      if(m!=0&&arr[m-1]<x) 
                          return m;
                      else if(m==0)
                          return m; 
        
                  // If x greater, ignore left half 
                  if (arr[m] < x) 
                      l = m + 1; 
        
                  // If x is smaller, ignore right half 
                  else
                      r = m - 1; 
              } 
        
              // if we reach here, then element was 
              // not present 
              return -1; 
          } 
          boolean check(char a,char b)
          {
              if(a==b)
                  return true;
              else
                  return false;
          }
          long binarySearch(long arr[], long x) 
          { 
              int l = 0, r = arr.length - 1,q=0; 
              while (l<=r) { 
                  int m = l + (r - l) / 2; 
                  if (arr[l] >=x) 
                  {
                      q=1;
                      return l; 
                  }
                  if (arr[m] < x) 
                      l=m+1; 
                  else
                      r=m;
              } 
              return -1;
          }
  
          static class InputReader {
              private InputStream stream;
              private byte[] buf = new byte[1024];
              private int curChar;
              private int numChars;
              private SpaceCharFilter filter;
              private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       
              public InputReader(InputStream stream) {
                  this.stream = stream;
              }
             
              public int read() {
                  if (numChars==-1)
                      throw new InputMismatchException();
                 
                  if (curChar >= numChars) {
                      curChar = 0;
                      try {
                          numChars = stream.read(buf);
                      }
                      catch (IOException e) {
                          throw new InputMismatchException();
                      }
                     
                      if(numChars <= 0)              
                          return -1;
                  }
                  return buf[curChar++];
              }
           
              public String nextLine() {
                  String str = "";
                  try {
                      str = br.readLine();
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
                  return str;
              }
              public int nextInt() {
                  int c = read();
                 
                  while(isSpaceChar(c))
                      c = read();
                 
                  int sgn = 1;
                 
                  if (c == '-') {
                      sgn = -1;
                      c = read();
                  }
                 
                  int res = 0;
                  do {
                      if(c<'0'||c>'9')
                          throw new InputMismatchException();
                      res *= 10;
                      res += c - '0';
                      c = read();
                  }
                  while (!isSpaceChar(c));
                 
                  return res * sgn;
              }
             
              public long nextLong() {
                  int c = read();
                  while (isSpaceChar(c))
                      c = read();
                  int sgn = 1;
                  if (c == '-') {
                      sgn = -1;
                      c = read();
                  }
                  long res = 0;
                 
                  do {
                      if (c < '0' || c > '9')
                          throw new InputMismatchException();
                      res *= 10;
                      res += c - '0';
                      c = read();
                  }
                  while (!isSpaceChar(c));
                      return res * sgn;
              }
             
              public double nextDouble() {
                  int c = read();
                  while (isSpaceChar(c))
                      c = read();
                  int sgn = 1;
                  if (c == '-') {
                      sgn = -1;
                      c = read();
                  }
                  double res = 0;
                  while (!isSpaceChar(c) && c != '.') {
                      if (c == 'e' || c == 'E')
                          return res * Math.pow(10, nextInt());
                      if (c < '0' || c > '9')
                          throw new InputMismatchException();
                      res *= 10;
                      res += c - '0';
                      c = read();
                  }
                  if (c == '.') {
                      c = read();
                      double m = 1;
                      while (!isSpaceChar(c)) {
                          if (c == 'e' || c == 'E')
                              return res * Math.pow(10, nextInt());
                          if (c < '0' || c > '9')
                              throw new InputMismatchException();
                          m /= 10;
                          res += (c - '0') * m;
                          c = read();
                      }
                  }
                  return res * sgn;
              }
             
              public String readString() {
                  int c = read();
                  while (isSpaceChar(c))
                      c = read();
                  StringBuilder res = new StringBuilder();
                  do {
                      res.appendCodePoint(c);
                      c = read();
                  }
                  while (!isSpaceChar(c));
                 
                  return res.toString();
              }
           
              public boolean isSpaceChar(int c) {
                  if (filter != null)
                      return filter.isSpaceChar(c);
                  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
              }
           
              public String next() {
                  return readString();
              }
             
              public interface SpaceCharFilter {
                  public boolean isSpaceChar(int ch);
              }
          }
  
          public static void main(String args[]) throws Exception {
              new Thread(null, new Solution2(),"Main",1<<27).start();
          }
      }
  