description: She does her utmost to flawlessly carry out a person's last rites and preserve the world's balance of yin and yang.
  
  Hu Tao, being the little prankster she is, has tried to scare you with this graph problem! You are given a connected undirected graph of n nodes with m edges. You also have q queries. Each query consists of two nodes a and b.
  
  Initially, all edges in the graph have a weight of 0. For each query, you must choose a simple path starting from a and ending at b. Then you add 1 to every edge along this path. Determine if it's possible, after processing all q queries, for all edges in this graph to have an even weight. If so, output the choice of paths for each query. 
  
  If it is not possible, determine the smallest number of extra queries you could add to make it possible. It can be shown that this number will not exceed 10^{18} under the given constraints.
  
  A simple path is defined as any path that does not visit a node more than once.
  
  An edge is said to have an even weight if its value is divisible by 2.
  
  Input
  
  The first line contains two integers n and m (2 ≤ n ≤ 3 ⋅ 10^5, n-1 ≤ m ≤ min{\left((n(n-1))/(2), 3 ⋅ 10^5\right)}).
  
  Each of the next m lines contains two integers x and y (1 ≤ x, y ≤ n, x≠ y) indicating an undirected edge between node x and y. The input will not contain self-loops or duplicate edges, and the provided graph will be connected.
  
  The next line contains a single integer q (1 ≤ q ≤ 3 ⋅ 10^5).
  
  Each of the next q lines contains two integers a and b (1 ≤ a, b ≤ n, a ≠ b), the description of each query.
  
  It is guaranteed that nq ≤ 3 ⋅ 10^5.
  
  Output
  
  If it is possible to force all edge weights to be even, print "YES" on the first line, followed by 2q lines indicating the choice of path for each query in the same order the queries are given. For each query, the first line should contain a single integer x: the number of nodes in the chosen path. The next line should then contain x spaced separated integers p_i indicating the path you take (p_1 = a, p_x = b and all numbers should fall between 1 and n). This path cannot contain duplicate nodes and must be a valid simple path in the graph.
  
  If it is impossible to force all edge weights to be even, print "NO" on the first line and the minimum number of added queries on the second line.
  
  Examples
  
  Input
  
  
  6 7
  2 1
  2 3
  3 5
  1 4
  6 1
  5 6
  4 5
  3
  1 4
  5 1
  4 5
  
  
  Output
  
  
  YES
  2
  1 4
  4
  5 3 2 1
  5
  4 1 2 3 5
  
  
  Input
  
  
  5 7
  4 3
  4 5
  2 1
  1 4
  1 3
  3 5
  3 2
  4
  4 2
  3 5
  5 1
  4 5
  
  
  Output
  
  
  NO
  2
  
  Note
  
  Here is what the queries look like for the first test case (red corresponds to the 1st query, blue 2nd query, and green 3rd query): 
  
  <image> Notice that every edge in the graph is part of either 0 or 2 colored query edges.
  
  The graph in the second test case looks like this: 
  
  <image> There does not exist an assignment of paths that will force all edges to have even weights with the given queries. One must add at least 2 new queries to obtain a set of queries that can satisfy the condition.
solution: import java.io.OutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.stream.IntStream;
  import java.util.Arrays;
  import java.util.ArrayList;
  import java.io.OutputStream;
  import java.io.IOException;
  import java.lang.reflect.Field;
  import java.nio.charset.StandardCharsets;
  import java.io.UncheckedIOException;
  import java.util.List;
  import java.util.stream.Stream;
  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);
              EMomentOfBloom solver = new EMomentOfBloom();
              solver.solve(1, in, out);
              out.close();
          }
      }
  
      static class EMomentOfBloom {
          List<UndirectedEdge>[] g;
          IntegerArrayList dq = new IntegerArrayList();
  
          public boolean dfs(int root, int p, int target) {
              dq.add(root);
  
              if (root == target) {
                  return true;
              }
  
              for (UndirectedEdge e : g[root]) {
                  if (e.to == p) {
                      continue;
                  }
                  if (dfs(e.to, root, target)) {
                      return true;
                  }
              }
  
              dq.pop();
              return false;
          }
  
          public void solve(int testNumber, FastInput in, FastOutput out) {
              int n = in.ri();
              int m = in.ri();
  
              DSU dsu = new DSU(n);
              g = Graph.createGraph(n);
              dsu.init();
  
              for (int i = 0; i < m; i++) {
                  int a = in.ri() - 1;
                  int b = in.ri() - 1;
  
                  if (dsu.find(a) == dsu.find(b)) {
                      continue;
                  }
                  dsu.merge(a, b);
                  Graph.addUndirectedEdge(g, a, b);
              }
  
              int q = in.ri();
              int[][] qs = new int[q][2];
              int[] deg = new int[n];
              for (int i = 0; i < q; i++) {
                  qs[i][0] = in.ri() - 1;
                  qs[i][1] = in.ri() - 1;
                  deg[qs[i][0]] ^= 1;
                  deg[qs[i][1]] ^= 1;
              }
  
              int sum = Arrays.stream(deg).sum();
              if (sum > 0) {
                  out.println("NO");
                  out.println(sum / 2);
                  return;
              }
              out.println("YES");
  
              for (int[] query : qs) {
                  dq.clear();
                  dfs(query[0], -1, query[1]);
                  out.println(dq.size());
                  for (int x : dq.toArray()) {
                      out.append(x + 1).append(' ');
                  }
                  out.println();
              }
          }
  
      }
  
      static class DirectedEdge {
          public int to;
  
          public DirectedEdge(int to) {
              this.to = to;
          }
  
          public String toString() {
              return "->" + to;
          }
  
      }
  
      static class FastInput {
          private final InputStream is;
          private byte[] buf = new byte[1 << 13];
          private int bufLen;
          private int bufOffset;
          private int next;
  
          public FastInput(InputStream is) {
              this.is = is;
          }
  
          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 int ri() {
              return readInt();
          }
  
          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;
          }
  
      }
  
      static class DSU {
          protected int[] p;
          public int[] size;
          protected int n;
  
          public DSU(int n) {
              p = new int[n];
              size = new int[n];
          }
  
          public void init() {
              init(p.length);
          }
  
          public void init(int n) {
              this.n = n;
              for (int i = 0; i < n; i++) {
                  p[i] = i;
                  size[i] = 1;
              }
          }
  
          public final int find(int a) {
              if (p[a] == p[p[a]]) {
                  return p[a];
              }
              find(p[a]);
              preAccess(a);
              return p[a] = p[p[a]];
          }
  
          protected void preAccess(int a) {
  
          }
  
          protected void preMerge(int a, int b) {
              size[a] += size[b];
          }
  
          public final void merge(int a, int b) {
              a = find(a);
              b = find(b);
              if (a == b) {
                  return;
              }
  
              if (size[a] < size[b]) {
                  int tmp = a;
                  a = b;
                  b = tmp;
              }
              preMerge(a, b);
              p[b] = a;
          }
  
          public String toString() {
              return Arrays.toString(Arrays.copyOf(p, n));
          }
  
      }
  
      static class UndirectedEdge extends DirectedEdge {
          public UndirectedEdge rev;
  
          public UndirectedEdge(int to) {
              super(to);
          }
  
          public String toString() {
              return String.format("%d<->%d", rev.to, to);
          }
  
      }
  
      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 append(String c) {
              cache.append(c);
              afterWrite();
              return this;
          }
  
          public FastOutput println(String c) {
              return append(c).println();
          }
  
          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 class Graph {
          public static UndirectedEdge makeUndirectedEdge(int s, int t) {
              UndirectedEdge toT = new UndirectedEdge(t);
              UndirectedEdge toS = new UndirectedEdge(s);
              toT.rev = toS;
              toS.rev = toT;
              return toT;
          }
  
          public static UndirectedEdge addUndirectedEdge(List<UndirectedEdge>[] g, int s, int t) {
              UndirectedEdge toT = makeUndirectedEdge(s, t);
              g[s].add(toT);
              g[t].add(toT.rev);
              return toT;
          }
  
          public static List[] createGraph(int n) {
              return IntStream.range(0, n).mapToObj(i -> new ArrayList<>()).toArray(i -> new List[i]);
          }
  
      }
  
      static class SequenceUtils {
          public static boolean equal(int[] a, int al, int ar, int[] b, int bl, int br) {
              if ((ar - al) != (br - bl)) {
                  return false;
              }
              for (int i = al, j = bl; i <= ar; i++, j++) {
                  if (a[i] != b[j]) {
                      return false;
                  }
              }
              return true;
          }
  
      }
  
      static class IntegerArrayList implements Cloneable {
          private int size;
          private int cap;
          private int[] data;
          private static final int[] EMPTY = new int[0];
  
          public IntegerArrayList(int cap) {
              this.cap = cap;
              if (cap == 0) {
                  data = EMPTY;
              } else {
                  data = new int[cap];
              }
          }
  
          public IntegerArrayList(int[] data) {
              this(0);
              addAll(data);
          }
  
          public IntegerArrayList(IntegerArrayList list) {
              this.size = list.size;
              this.cap = list.cap;
              this.data = Arrays.copyOf(list.data, size);
          }
  
          public IntegerArrayList() {
              this(0);
          }
  
          public void ensureSpace(int req) {
              if (req > cap) {
                  while (cap < req) {
                      cap = Math.max(cap + 10, 2 * cap);
                  }
                  data = Arrays.copyOf(data, cap);
              }
          }
  
          public void add(int x) {
              ensureSpace(size + 1);
              data[size++] = x;
          }
  
          public void addAll(int[] x) {
              addAll(x, 0, x.length);
          }
  
          public void addAll(int[] x, int offset, int len) {
              ensureSpace(size + len);
              System.arraycopy(x, offset, data, size, len);
              size += len;
          }
  
          public void addAll(IntegerArrayList list) {
              addAll(list.data, 0, list.size);
          }
  
          public int pop() {
              return data[--size];
          }
  
          public int size() {
              return size;
          }
  
          public int[] toArray() {
              return Arrays.copyOf(data, size);
          }
  
          public void clear() {
              size = 0;
          }
  
          public String toString() {
              return Arrays.toString(toArray());
          }
  
          public boolean equals(Object obj) {
              if (!(obj instanceof IntegerArrayList)) {
                  return false;
              }
              IntegerArrayList other = (IntegerArrayList) obj;
              return SequenceUtils.equal(data, 0, size - 1, other.data, 0, other.size - 1);
          }
  
          public int hashCode() {
              int h = 1;
              for (int i = 0; i < size; i++) {
                  h = h * 31 + Integer.hashCode(data[i]);
              }
              return h;
          }
  
          public IntegerArrayList clone() {
              IntegerArrayList ans = new IntegerArrayList();
              ans.addAll(this);
              return ans;
          }
  
      }
  }
  
  