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: // Generated by Code Flattener.
  // https://plugins.jetbrains.com/plugin/9979-idea-code-flattener
  
  import java.io.*;
  import java.util.*;
  
  public class Main {
      public static void main(String[] args) {
          Solution solution = new ASolution();
          boolean local = System.getProperty("ONLINE_JUDGE") == null && !solution.isInteractive();
          String input = local ? "input.txt" : null;
          solution.in = new MyScanner(input);
          solution.out = MyWriter.of(null);
          solution.bm = new Benchmark();
          solution.al = new Algorithm();
          solution.run();
          solution.close();
      }
  
      private abstract static class Solution {
          public MyScanner in;
          public MyWriter out;
          public Benchmark bm;
          public Algorithm al;
  
          public void init() {
          }
  
          public abstract void solve();
  
          protected boolean isMultiTest() {
              return true;
          }
  
          public void run() {
              init();
              if (isMultiTest()) {
                  int t = in.nextInt();
                  for (int i = 0; i < t; i++) {
                      solve();
                  }
              } else {
                  solve();
              }
          }
  
          public void close() {
              out.close();
          }
  
          public boolean isInteractive() {
              return false;
          }
      }
  
      private static class ASolution extends Solution {
          class Node {
              int u;
              int v;
  
              public Node(int u, int v) {
                  this.u = u;
                  this.v = v;
              }
          }
  
          private void bfs(Vertex u, Graph tree, boolean[] was) {
              was[u.getIndex()] = true;
              for (Vertex v : u.getNeighbors()) {
                  if (!was[v.getIndex()]) {
                      tree.add(u.getIndex(), v.getIndex());
                      bfs(v, tree, was);
                  }
              }
          }
  
          private boolean bfs(Vertex p, Vertex u, Vertex end, List<Integer> path) {
              if (u.equals(end)) {
                  path.add(u.getIndex());
                  return true;
              }
              for (Vertex v : u.getNeighbors()) {
                  if (!v.equals(p)) {
                      if (bfs(u, v, end, path)) {
                          path.add(u.getIndex());
                          return true;
                      }
                  }
              }
              return false;
          }
  
          public void solve() {
              int n = in.nextInt();
              int m = in.nextInt();
              Graph graph = new Graph(n);
              for (int i = 0; i < m; i++) {
                  int u = in.nextInt() - 1;
                  int v = in.nextInt() - 1;
                  graph.add(u, v);
              }
              int q = in.nextInt();
              int[] count = new int[n];
              Node[] nodes = new Node[q];
              for (int i = 0; i < q; i++) {
                  int u = in.nextInt() - 1;
                  int v = in.nextInt() - 1;
                  nodes[i] = new Node(u, v);
                  count[u]++;
                  count[v]++;
              }
  
              int odd = 0;
              for (int el : count) {
                  if (el % 2 == 1) {
                      odd++;
                  }
              }
              if (odd > 0) {
                  out.println("NO");
                  out.println(odd / 2);
                  return;
              }
              out.println("YES");
  
              Graph tree = new Graph(n);
              bfs(graph.get(0), tree, new boolean[n]);
              for (Node node : nodes) {
                  List<Integer> path = new ArrayList<>();
                  bfs(null, tree.get(node.u), tree.get(node.v), path);
                  Collections.reverse(path);
                  out.println(path.size());
                  for (Integer el : path) {
                      out.print(el + 1 + " ");
                  }
                  out.println();
              }
          }
  
          @Override
          protected boolean isMultiTest() {
              return false;
          }
      }
  
      private static class MyScanner {
          private final BufferedReader br;
          private StringTokenizer st;
  
          public MyScanner(String fileName) {
              if (fileName != null) {
                  try {
                      File file = new File(getClass().getClassLoader().getResource(fileName).getFile());
                      br = new BufferedReader(new FileReader(file));
                  } catch (FileNotFoundException e) {
                      throw new RuntimeException(e);
                  }
              } else {
                  br = new BufferedReader(new InputStreamReader(System.in));
              }
          }
  
          public String next() {
              while (st == null || !st.hasMoreElements()) {
                  st = new StringTokenizer(nextLine());
              }
              return st.nextToken();
          }
  
          public int nextInt() {
              return Integer.parseInt(next());
          }
  
          public String nextLine() {
              try {
                  String line = br.readLine();
                  if (line == null) {
                      throw new RuntimeException("empty line");
                  }
                  st = null;
                  return line;
              } catch (IOException e) {
                  throw new RuntimeException(e);
              }
          }
      }
  
      private static class Benchmark {
      }
  
      private static class Algorithm {
      }
  
      private static class MyWriter extends PrintWriter {
          public static MyWriter of(String fileName) {
              if (fileName != null) {
                  try {
                      return new MyWriter(new FileWriter(fileName));
                  } catch (IOException e) {
                      throw new RuntimeException(e);
                  }
              } else {
                  return new MyWriter(new BufferedOutputStream(System.out));
              }
          }
  
          public MyWriter(Writer writer) {
              super(writer);
          }
  
          public MyWriter(OutputStream out) {
              super(out);
          }
      }
  
      private static class Graph extends AbstractList<Vertex> {
          private final Vertex[] vertices;
  
          public Graph(int n) {
              vertices = new Vertex[n];
              for (int i = 0; i < n; i++) {
                  vertices[i] = new Vertex(i);
              }
          }
  
          public void add(int u, int v) {
              vertices[u].neighbors.add(vertices[v]);
              vertices[v].neighbors.add(vertices[u]);
          }
  
          @Override
          public int size() {
              return vertices.length;
          }
  
          @Override
          public Vertex get(int index) {
              return vertices[index];
          }
      }
  
      private static class Vertex {
          int index;
          Set<Vertex> neighbors;
  
          Vertex(int index) {
              this.index = index;
              this.neighbors = new HashSet<>();
          }
  
          public int getIndex() {
              return index;
          }
  
          public Set<Vertex> getNeighbors() {
              return Collections.unmodifiableSet(neighbors);
          }
  
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
              Vertex vertex = (Vertex) o;
              return index == vertex.index;
          }
  
          @Override
          public int hashCode() {
              return Objects.hash(index);
          }
      }
  }