10 9 5
0 0 0 0 0 0 0 0 0 4
10 3
10 7
10 5
10 8
10 9
10 1
10 4
10 6
10 2
 10 20 5
2 2 1 4 0 3 0 4 1 3
6 1
8 5
2 10
3 5
1 9
4 6
9 7
2 3
7 4
10 8
4 9
2 5
4 10
2 8
10 3
1 8
8 10
6 7
5 1
10 3
 10 9 2
1 1 0 1 1 1 1 1 1 1
3 10
3 8
3 6
3 7
3 5
3 4
3 1
3 9
3 2
 10 10 5
3 4 2 0 3 0 1 1 2 4
8 9
7 3
5 2
4 8
3 5
6 8
3 5
1 10
10 6
9 1
 10 30 10
7 9 1 5 4 6 0 3 8 2
10 8
8 5
6 1
8 5
3 10
10 8
9 2
8 5
7 3
3 10
1 9
10 8
6 1
1 9
8 5
7 3
1 9
7 3
7 3
4 6
10 8
7 3
3 10
10 8
1 9
8 5
6 1
4 6
3 10
6 1
 6 7 3
0 1 2 0 1 2
1 2
2 3
3 1
3 4
4 5
5 6
6 4
 10 9 2
0 1 0 0 1 0 1 1 1 1
3 7
3 2
8 6
1 7
3 9
5 4
10 1
4 9
6 2
 10 10 10
2 3 5 7 0 8 6 9 4 1
1 2
10 1
5 10
5 10
4 6
8 5
1 2
1 2
7 4
1 2
 10 9 5
1 1 1 1 1 2 1 1 1 1
6 7
6 3
6 5
6 4
6 9
6 8
6 1
6 10
6 2
 10 9 2
0 0 0 0 1 1 0 1 1 1
4 10
8 2
10 3
3 9
1 5
6 2
6 1
7 9
8 7
 5 5 3
2 2 0 1 0
5 4
5 2
1 4
5 1
4 3
 10 9 5
0 4 1 0 1 2 1 0 4 4
8 7
4 3
1 5
2 4
6 5
10 8
9 1
6 7
6 3
 7 8 3
0 0 1 2 2 0 1
1 5
4 3
7 5
1 7
3 2
2 4
6 7
6 5
 10 30 7
5 4 2 3 3 2 5 0 1 6
7 2
2 4
9 3
3 5
5 2
7 10
6 5
10 1
9 8
10 8
3 4
10 4
4 2
7 6
2 8
1 10
5 10
5 6
5 6
6 2
6 5
9 10
8 6
2 4
9 7
1 9
10 4
6 10
9 3
2 7
 5 5 3
1 1 2 0 0
1 3
1 5
2 3
3 4
2 4
 10 10 2
1 1 1 0 1 0 0 0 0 1
4 10
10 7
7 1
5 6
6 3
1 8
2 9
5 4
3 8
2 9
 9 13 3
0 2 1 2 2 0 1 0 1
4 7
9 5
7 5
7 6
9 6
8 2
3 2
8 3
4 3
4 9
1 2
1 3
5 6
 6 3 3
0 1 2 0 1 2
4 5
5 6
4 6
 10 10 5
3 3 3 4 4 1 3 0 2 4
7 5
10 8
10 8
5 8
2 10
9 2
7 4
3 4
7 5
4 8
 10 15 2
1 0 1 1 0 0 1 0 0 1
5 1
7 8
2 10
3 5
1 9
6 4
7 9
2 3
6 4
8 10
9 4
8 4
8 1
10 8
6 7
 2 1 2
1 0
1 2
 5 5 4
0 1 2 3 3
1 2
2 3
3 4
4 1
3 5
 10 9 5
2 1 2 0 1 0 1 2 0 4
10 9
3 7
1 5
10 6
7 9
10 4
5 4
2 6
8 2
 9 10 3
0 2 2 1 0 0 1 2 1
4 6
2 6
5 7
4 8
9 2
9 1
3 5
8 1
3 7
6 2
 10 20 3
2 2 1 1 2 0 0 1 2 2
7 5
7 10
2 7
10 4
10 8
1 7
3 7
9 7
3 10
6 3
4 1
4 1
8 6
3 7
10 3
2 7
8 5
2 7
1 4
2 6
 10 9 8
3 2 1 1 5 6 7 0 4 0
10 7
5 9
10 4
7 6
6 5
3 2
2 1
9 1
3 8

1
1 
 5
1 4 6 7 9 
 10
1 2 3 4 5 6 7 8 9 10 
 1
2 
 1
2 
 3
4 5 6 
 10
1 2 3 4 5 6 7 8 9 10 
 1
2 
 1
6 
 10
1 2 3 4 5 6 7 8 9 10 
 3
1 4 5 
 1
6 
 3
2 3 4 
 8
2 3 4 5 7 8 9 10 
 3
2 3 4 
 2
2 9 
 1
4 
 1
1 
 1
1 
 10
1 2 3 4 5 6 7 8 9 10 
 2
1 2 
 1
5 
 1
1 
 3
3 5 7 
 3
3 7 10 
 1
4 

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.io.IOException;
import java.io.Writer;
import java.util.NoSuchElementException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author palayutm
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        ProblemCDataCenterMaintenance solver = new ProblemCDataCenterMaintenance();
        solver.solve(1, in, out);
        out.close();
    }

    static class ProblemCDataCenterMaintenance {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt(), m = in.nextInt(), H = in.nextInt();
            Graph g = new Graph(n);
            int[] h = in.nextIntArray(n);
            for (int i = 0; i < m; i++) {
                int c1 = in.nextInt(), c2 = in.nextInt();
                if (h[c1 - 1] == (h[c2 - 1] + 1) % H) {
                    g.addEdge(c2 - 1, c1 - 1);
                }
                if (h[c2 - 1] == (h[c1 - 1] + 1) % H) {
                    g.addEdge(c1 - 1, c2 - 1);
                }
            }
            StronglyConnectedComponent scc = new Tarjan(g);
            int[] outDegree = new int[scc.getComponentsNumber()];
            for (int i = 0; i < n; i++) {
                for (Edge edge : g.getEdges(i)) {
                    if (scc.getComponentID(i) != scc.getComponentID(edge.to)) {
                        outDegree[scc.getComponentID(i)]++;
                    }
                }
            }
            int[][] components = scc.getComponents();
            int p = -1, mi = n * 3;
            for (int i = 0; i < components.length; i++) {
                if (outDegree[i] == 0 && components[i].length < mi) {
                    mi = components[i].length;
                    p = i;
                }
            }
            out.println(components[p].length);
            for (int i = 0; i < components[p].length; i++) {
                out.print(components[p][i] + 1 + " ");
            }
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] inbuf = new byte[1024];
        private int lenbuf = 0;
        private int ptrbuf = 0;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        private int readByte() {
            if (lenbuf == -1) throw new UnknownError();
            if (ptrbuf >= lenbuf) {
                ptrbuf = 0;
                try {
                    lenbuf = stream.read(inbuf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (lenbuf <= 0) return -1;
            }
            return inbuf[ptrbuf++];
        }

        public int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextInt();
            }
            return a;
        }

    }

    static class Edge {
        public int to;
        public long weight;

        public Edge(int to) {
            this.to = to;
        }

        public Edge(int to, long weight) {
            this(to);
            this.weight = weight;
        }

    }

    static class Graph {
        MyArrayList<Edge>[] g;

        public Graph(int n) {
            g = new MyArrayList[n];
            for (int i = 0; i < n; i++) {
                g[i] = new MyArrayList();
            }
        }

        public void addEdge(int from, int to) {
            g[from].add(new Edge(to));
        }

        public MyArrayList<Edge> getEdges(int from) {
            return g[from];
        }

        public int getVertexNumber() {
            return g.length;
        }

    }

    static interface StronglyConnectedComponent {
        int getComponentID(int vertexID);

        int getComponentsNumber();

        int[][] getComponents();

    }

    static class Tarjan implements StronglyConnectedComponent {
        int[] dfn;
        int[] state;
        int[] low;
        int vertexNum;
        int lay;
        int scc;
        IntArrayList stack;

        public Tarjan(Graph g) {
            vertexNum = g.getVertexNumber();
            dfn = new int[vertexNum];
            state = new int[vertexNum];
            low = new int[vertexNum];
            stack = new IntArrayList();
            for (int i = 0; i < vertexNum; i++) {
                if (state[i] == 0) dfs(g, i);
            }
        }

        void dfs(Graph g, int u) {
            state[u] = 1;
            dfn[u] = low[u] = ++lay;
            stack.add(u);
            for (Edge e : g.getEdges(u)) {
                if (state[e.to] == 0) dfs(g, e.to);
                if (state[e.to] == 1) low[u] = Math.min(low[u], low[e.to]);
            }
            if (low[u] == dfn[u]) {
                while (true) {
                    int v = stack.remove();
                    low[v] = scc;
                    state[v] = 2;
                    if (v == u) break;
                }
                scc++;
            }
        }


        public int getComponentID(int vertexID) {
            return low[vertexID];
        }


        public int getComponentsNumber() {
            return scc;
        }


        public int[][] getComponents() {
            int[][] ret = new int[scc][];
            IntArrayList[] components = new IntArrayList[scc];
            for (int i = 0; i < scc; i++) components[i] = new IntArrayList();
            for (int i = 0; i < vertexNum; i++) components[low[i]].add(i);
            for (int i = 0; i < scc; i++) ret[i] = components[i].toArray();
            return ret;
        }

    }

    static class IntArrayList {
        private static final int DEFAULT_CAPACITY = 10;
        int[] array;
        int size;

        public IntArrayList() {
            this(DEFAULT_CAPACITY);
        }

        public IntArrayList(int capacity) {
            array = new int[capacity];
            size = 0;
        }

        public IntArrayList(int size, int initialValue) {
            String s;
            array = new int[size];
            Arrays.fill(array, initialValue);
            this.size = size;
        }

        public IntArrayList(int[] src) {
            array = Arrays.copyOf(src, src.length);
            size = array.length;
        }

        public void add(int value) {
            if (size == array.length) {
                enLarge();
            }
            array[size++] = value;
        }

        public int remove() {
            if (size == 0) {
                throw new NoSuchElementException();
            }
            return array[--size];
        }

        public int[] toArray() {
            return Arrays.copyOf(array, size);
        }

        private void enLarge() {
            int[] newArray = new int[(int) (array.length << 1)];
            System.arraycopy(array, 0, newArray, 0, size);
            array = newArray;
        }

    }

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream out) {
            super(out);
        }

        public OutputWriter(Writer out) {
            super(out);
        }

        public void close() {
            super.close();
        }

    }

    static class MyArrayList<T> implements Iterable<T> {
        private static final int DEFAULT_CAPACITY = 10;
        private static final double ENLARGE_SCALE = 2.0;
        Object[] array;
        int size;

        public MyArrayList() {
            this(DEFAULT_CAPACITY);
        }

        public MyArrayList(int capacity) {
            array = new Object[capacity];
            size = 0;
        }

        public void add(T value) {
            if (size == array.length) {
                enLarge();
            }
            array[size++] = value;
        }

        private void enLarge() {
            Object[] newArray = new Object[(int) (array.length * ENLARGE_SCALE)];
            System.arraycopy(array, 0, newArray, 0, size);
            array = newArray;
        }


        public Iterator<T> iterator() {
            return new Iterator<T>() {
                private int currentIndex = 0;


                public boolean hasNext() {
                    return currentIndex < size;
                }


                public T next() {
                    return (T) array[currentIndex++];
                }
            };
        }

    }
}

