description: A bow adorned with nameless flowers that bears the earnest hopes of an equally nameless person.
  
  You have obtained the elegant bow known as the Windblume Ode. Inscribed in the weapon is an array of n (n ≥ 3) positive distinct integers (i.e. different, no duplicates are allowed).
  
  Find the largest subset (i.e. having the maximum number of elements) of this array such that its sum is a composite number. A positive integer x is called composite if there exists a positive integer y such that 1 < y < x and x is divisible by y.
  
  If there are multiple subsets with this largest size with the composite sum, you can output any of them. It can be proven that under the constraints of the problem such a non-empty subset always exists.
  
  Input
  
  Each test consists of 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 an integer n (3 ≤ n ≤ 100) — the length of the array.
  
  The second line of each test case contains n distinct integers a_{1},a_{2},...,a_{n} (1 ≤ a_{i} ≤ 200) — the elements of the array.
  
  Output
  
  Each test case should have two lines of output.
  
  The first line should contain a single integer x: the size of the largest subset with composite sum. The next line should contain x space separated integers representing the indices of the subset of the initial array.
  
  Example
  
  Input
  
  
  4
  3
  8 1 2
  4
  6 9 4 2
  9
  1 2 3 4 5 6 7 8 9
  3
  200 199 198
  
  
  Output
  
  
  2
  2 1
  4
  2 1 4 3
  9
  6 9 1 2 3 4 5 7 8
  3
  1 2 3 
  
  Note
  
  In the first test case, the subset \\{a_2, a_1\} has a sum of 9, which is a composite number. The only subset of size 3 has a prime sum equal to 11. Note that you could also have selected the subset \\{a_1, a_3\} with sum 8 + 2 = 10, which is composite as it's divisible by 2.
  
  In the second test case, the sum of all elements equals to 21, which is a composite number. Here we simply take the whole array as our subset.
solution: import java.io.OutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.stream.IntStream;
  import java.util.Arrays;
  import java.io.OutputStream;
  import java.io.IOException;
  import java.lang.reflect.Field;
  import java.nio.charset.StandardCharsets;
  import java.io.Serializable;
  import java.io.UncheckedIOException;
  import java.io.Closeable;
  import java.io.InputStream;
  
  /**
   * Built using CHelper plug-in
   * Actual solution is at the top
   */
  public class Main {
      public static void main(String[] args) throws Exception {
          Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 29);
          thread.start();
          thread.join();
      }
  
      static class TaskAdapter implements Runnable {
          @Override
          public void run() {
              InputStream inputStream = System.in;
              OutputStream outputStream = System.out;
              FastInput in = new FastInput(inputStream);
              FastOutput out = new FastOutput(outputStream);
              AWindblumeOde solver = new AWindblumeOde();
              int testCount = Integer.parseInt(in.next());
              for (int i = 1; i <= testCount; i++)
                  solver.solve(i, in, out);
              out.close();
          }
      }
  
      static class AWindblumeOde {
          EulerSieve sieve = new EulerSieve((int) 1e5);
  
          public void solve(int testNumber, FastInput in, FastOutput out) {
              int n = in.ri();
              int[] a = in.ri(n);
              boolean[] added = new boolean[n];
              Arrays.fill(added, true);
              int sum = Arrays.stream(a).sum();
              if (sieve.isPrime(sum)) {
                  for (int i = 0; i < n; i++) {
                      if (sieve.isComp(sum - a[i])) {
                          added[i] = false;
                          break;
                      }
                  }
              }
              int cnt = 0;
              for (boolean x : added) {
                  if (x) {
                      cnt++;
                  }
              }
              out.println(cnt);
              for (int i = 0; i < n; i++) {
                  if (added[i]) {
                      out.append(i + 1).append(' ');
                  }
              }
              out.println();
          }
  
      }
  
      static class FastInput {
          private final InputStream is;
          private StringBuilder defaultStringBuf = new StringBuilder(1 << 13);
          private byte[] buf = new byte[1 << 13];
          private int bufLen;
          private int bufOffset;
          private int next;
  
          public FastInput(InputStream is) {
              this.is = is;
          }
  
          public void populate(int[] data) {
              for (int i = 0; i < data.length; i++) {
                  data[i] = readInt();
              }
          }
  
          private int read() {
              while (bufLen == bufOffset) {
                  bufOffset = 0;
                  try {
                      bufLen = is.read(buf);
                  } catch (IOException e) {
                      bufLen = -1;
                  }
                  if (bufLen == -1) {
                      return -1;
                  }
              }
              return buf[bufOffset++];
          }
  
          public void skipBlank() {
              while (next >= 0 && next <= 32) {
                  next = read();
              }
          }
  
          public String next() {
              return readString();
          }
  
          public int ri() {
              return readInt();
          }
  
          public int[] ri(int n) {
              int[] ans = new int[n];
              populate(ans);
              return ans;
          }
  
          public int readInt() {
              boolean rev = false;
  
              skipBlank();
              if (next == '+' || next == '-') {
                  rev = next == '-';
                  next = read();
              }
  
              int val = 0;
              while (next >= '0' && next <= '9') {
                  val = val * 10 - next + '0';
                  next = read();
              }
  
              return rev ? val : -val;
          }
  
          public String readString(StringBuilder builder) {
              skipBlank();
  
              while (next > 32) {
                  builder.append((char) next);
                  next = read();
              }
  
              return builder.toString();
          }
  
          public String readString() {
              defaultStringBuf.setLength(0);
              return readString(defaultStringBuf);
          }
  
      }
  
      static class FastOutput implements AutoCloseable, Closeable, Appendable {
          private static final int THRESHOLD = 32 << 10;
          private OutputStream writer;
          private StringBuilder cache = new StringBuilder(THRESHOLD * 2);
          private static Field stringBuilderValueField;
          private char[] charBuf = new char[THRESHOLD * 2];
          private byte[] byteBuf = new byte[THRESHOLD * 2];
  
          static {
              try {
                  stringBuilderValueField = StringBuilder.class.getSuperclass().getDeclaredField("value");
                  stringBuilderValueField.setAccessible(true);
              } catch (Exception e) {
                  stringBuilderValueField = null;
              }
              stringBuilderValueField = null;
          }
  
          public FastOutput append(CharSequence csq) {
              cache.append(csq);
              return this;
          }
  
          public FastOutput append(CharSequence csq, int start, int end) {
              cache.append(csq, start, end);
              return this;
          }
  
          private void afterWrite() {
              if (cache.length() < THRESHOLD) {
                  return;
              }
              flush();
          }
  
          public FastOutput(OutputStream writer) {
              this.writer = writer;
          }
  
          public FastOutput append(char c) {
              cache.append(c);
              afterWrite();
              return this;
          }
  
          public FastOutput append(int c) {
              cache.append(c);
              afterWrite();
              return this;
          }
  
          public FastOutput println(int c) {
              return append(c).println();
          }
  
          public FastOutput println() {
              return append('\n');
          }
  
          public FastOutput flush() {
              try {
                  if (stringBuilderValueField != null) {
                      try {
                          byte[] value = (byte[]) stringBuilderValueField.get(cache);
                          writer.write(value, 0, cache.length());
                      } catch (Exception e) {
                          stringBuilderValueField = null;
                      }
                  }
                  if (stringBuilderValueField == null) {
                      int n = cache.length();
                      if (n > byteBuf.length) {
                          //slow
                          writer.write(cache.toString().getBytes(StandardCharsets.UTF_8));
  //                writer.append(cache);
                      } else {
                          cache.getChars(0, n, charBuf, 0);
                          for (int i = 0; i < n; i++) {
                              byteBuf[i] = (byte) charBuf[i];
                          }
                          writer.write(byteBuf, 0, n);
                      }
                  }
                  writer.flush();
                  cache.setLength(0);
              } catch (IOException e) {
                  throw new UncheckedIOException(e);
              }
              return this;
          }
  
          public void close() {
              flush();
              try {
                  writer.close();
              } catch (IOException e) {
                  throw new UncheckedIOException(e);
              }
          }
  
          public String toString() {
              return cache.toString();
          }
  
      }
  
      static final class BitSet implements Serializable, Cloneable, Comparable<BitSet> {
          private long[] data;
          private long tailAvailable;
          private int capacity;
          private int m;
          private static final int SHIFT = 6;
          private static final int LOW = 63;
          private static final int BITS_FOR_EACH = 64;
          private static final long ALL_ONE = ~0L;
          private static final long ALL_ZERO = 0L;
          private static final int MAX_OFFSET = 63;
          private static long[] EMPTY_ARRAY = new long[0];
  
          public BitSet(int n) {
              capacity = n;
              this.m = (capacity + 64 - 1) / 64;
              data = new long[m];
              tailAvailable = oneBetween(0, offset(capacity - 1));
          }
  
          public BitSet(BitSet bs) {
              this.data = bs.data.clone();
              this.tailAvailable = bs.tailAvailable;
              this.capacity = bs.capacity;
              this.m = bs.m;
          }
  
          private BitSet(BitSet bs, int l, int r) {
              this.data = EMPTY_ARRAY;
              copyInterval(bs, l, r);
          }
  
          public void copyInterval(BitSet bs, int l, int r) {
              capacity = r - l + 1;
              tailAvailable = oneBetween(0, offset(capacity - 1));
              int reqLength = word(r) - word(l) + 1;
              if (data.length >= word(r) - word(l) + 1) {
                  System.arraycopy(bs.data, word(l), data, 0, reqLength);
              } else {
                  data = Arrays.copyOfRange(bs.data, word(l), word(r) + 1);
              }
              this.m = reqLength;
              leftShift(offset(l));
              this.m = (capacity + 64 - 1) / 64;
              data[m - 1] &= tailAvailable;
              for (int i = m; i < reqLength; i++) {
                  data[i] = 0;
              }
          }
  
          public boolean get(int i) {
              return (data[word(i)] & (1L << offset(i))) != 0;
          }
  
          public void set(int i) {
              data[word(i)] |= (1L << offset(i));
          }
  
          private static int word(int i) {
              return i >>> SHIFT;
          }
  
          private static int offset(int i) {
              return i & LOW;
          }
  
          private long oneBetween(int l, int r) {
              if (r < l) {
                  return 0;
              }
              long lBegin = 1L << offset(l);
              long rEnd = 1L << offset(r);
              return (ALL_ONE ^ (lBegin - 1)) & ((rEnd << 1) - 1);
          }
  
          public int capacity() {
              return capacity;
          }
  
          public int nextSetBit(int start) {
              int offset = offset(start);
              int w = word(start);
              if (offset != 0) {
                  long mask = oneBetween(offset, MAX_OFFSET);
                  if ((data[w] & mask) != 0) {
                      return Long.numberOfTrailingZeros(data[w] & mask) + w * BITS_FOR_EACH;
                  }
                  w++;
              }
  
              while (w < m && data[w] == ALL_ZERO) {
                  w++;
              }
              if (w >= m) {
                  return capacity();
              }
              return Long.numberOfTrailingZeros(data[w]) + w * BITS_FOR_EACH;
          }
  
          public void leftShift(int n) {
              int wordMove = word(n);
              int offsetMove = offset(n);
              int rshift = MAX_OFFSET - (offsetMove - 1);
  
              if (offsetMove != 0) {
                  //slightly
                  for (int i = 0; i < m; i++) {
                      if (i > 0) {
                          data[i - 1] |= data[i] << rshift;
                      }
                      data[i] >>>= offsetMove;
                  }
              }
              if (wordMove > 0) {
                  for (int i = 0; i < m; i++) {
                      if (i >= wordMove) {
                          data[i - wordMove] = data[i];
                      }
                      data[i] = 0;
                  }
              }
          }
  
          public BitSet clone() {
              return new BitSet(this);
          }
  
          public String toString() {
              StringBuilder builder = new StringBuilder("{");
              for (int i = nextSetBit(0); i < capacity(); i = nextSetBit(i + 1)) {
                  builder.append(i).append(',');
              }
              if (builder.length() > 1) {
                  builder.setLength(builder.length() - 1);
              }
              builder.append("}");
              return builder.toString();
          }
  
          public int hashCode() {
              int ans = 1;
              for (int i = 0; i < m; i++) {
                  ans = ans * 31 + Long.hashCode(data[i]);
              }
              return ans;
          }
  
          public boolean equals(Object obj) {
              if (!(obj instanceof BitSet)) {
                  return false;
              }
              BitSet other = (BitSet) obj;
              if (other.capacity != capacity) {
                  return false;
              }
              for (int i = 0; i < m; i++) {
                  if (other.data[i] != data[i]) {
                      return false;
                  }
              }
              return true;
          }
  
          public int compareTo(BitSet o) {
              if (capacity != o.capacity) {
                  return Integer.compare(capacity, o.capacity);
              }
              return SortUtils.compareArray(data, 0, m - 1,
                      o.data, 0, m - 1);
          }
  
      }
  
      static class SortUtils {
          private SortUtils() {
          }
  
          public static int compareArray(long[] a, int al, int ar, long[] b, int bl, int br) {
              for (int i = al, j = bl; i <= ar && j <= br; i++, j++) {
                  if (a[i] != b[j]) {
                      return Long.compare(a[i], b[j]);
                  }
              }
              return (ar - al) - (br - bl);
          }
  
      }
  
      static class EulerSieve {
          private int[] primes;
          private BitSet isComp;
          private int primeLength;
          private static int[] phi = new int[]{
                  4, 25, 168, 1229, 9592, 78498, 664579, 5761455, 50847534, 455052511
          };
  
          public boolean isPrime(int x) {
              if (x <= 1) {
                  return false;
              }
              return !isComp.get(x);
          }
  
          public boolean isComp(int x) {
              if (x <= 1) {
                  return false;
              }
              return isComp.get(x);
          }
  
          private int estimatePhi(int n) {
              long x = 10;
              int i = 0;
              while (x < n) {
                  x *= 10;
                  i++;
              }
              return phi[i];
          }
  
          public EulerSieve(int limit) {
              isComp = new BitSet(limit + 1);
              primes = new int[estimatePhi(limit)];
              primeLength = 0;
              for (int i = 2; i <= limit; i++) {
                  if (!isComp.get(i)) {
                      primes[primeLength++] = i;
                  }
                  int pi;
                  for (int j = 0; j < primeLength && (pi = primes[j] * i) <= limit; j++) {
                      isComp.set(pi);
                      if (i % primes[j] == 0) {
                          break;
                      }
                  }
              }
          }
  
      }
  }
  
  