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

2
1
2
 0

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;

public class Main {
    private static FastReader sc = new FastReader(System.in);
    private static OutputWriter out = new OutputWriter(System.out);
    private static HashMap<Integer, ArrayList<Integer>> graph;
    private static int n;
    private static int[] d;
    private static Edge[] edges;
    private static HashMap<Integer, ArrayList<Edge>> mst;
    private static ArrayList<Edge> mstEdges;
    private static ArrayList<Edge> ans;

    public static void main(String[] args) throws Exception {
        n = sc.nextInt();
        int m = sc.nextInt();
        d = new int[n];
        graph = new HashMap<>();
        for (int i = 0; i < n; i++) graph.put(i, new ArrayList<>());
        for (int i = 0; i < n; i++) d[i] = sc.nextInt();
        edges = new Edge[m];
        for (int i = 0; i < m; i++) {
            int u = sc.nextInt() - 1;
            int v = sc.nextInt() - 1;
            graph.get(u).add(v);
            graph.get(v).add(u);
            edges[i] = new Edge(i, u, v);
        }
        if (!changeDegree()) {
            System.out.println(-1);
            System.exit(0);
        }
//        System.out.println(Arrays.toString(d));

        MST();
        ans = new ArrayList<>();
        for (Edge e : mst.get(0)) {
            dfs(other(e, 0), e);
        }

        out.printLine(ans.size());
        for (Edge e : ans) {
            out.printLine(e.id + 1);
        }
        out.close();
    }

    private static void dfs(int u, Edge e) {
        if (mst.get(u).size() == 1) {
            if (d[u] == 1) {
                ans.add(e);
                d[u] = 0;
                d[other(e, u)] = 1 - d[other(e, u)];
            }
            return;
        }

        for (Edge ez : mst.get(u)) {
            if (ez.id != e.id) dfs(other(ez, u), ez);
        }

        if (d[u] == 1) {
            ans.add(e);
            d[u] = 0;
            d[other(e, u)] = 1 - d[other(e, u)];
        }
    }

    private static int other(Edge e, int u) {
        if (e.u == u) return e.v;
        return e.u;
    }

    private static void MST() {
        mst = new HashMap<>();
        mstEdges = new ArrayList<>();
        for (int i = 0; i < n; i++) mst.put(i, new ArrayList<>());
        UnionFind uf = new UnionFind(n);
        for (int i = 0; i < edges.length; i++) {
            int u = edges[i].u, v = edges[i].v;
            if (!uf.connected(u, v)) {
                uf.union(u, v);
                mst.get(u).add(edges[i]);
                mst.get(v).add(edges[i]);
                mstEdges.add(edges[i]);
            }
        }
    }

    private static boolean changeDegree() {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            if (d[i] != -1) sum += d[i];
        }
        for (int i = 0; i < n; i++) {
            if (d[i] == -1 && sum % 2 == 0) {
                d[i] = 0;
            } else if (d[i] == -1 && sum % 2 == 1) {
                d[i] = 1;
                sum++;
            }
        }
        return sum % 2 == 0;
    }
}

class Edge {
    int id, u, v;
    public Edge(int i, int p, int q) {
        id = i;
        u = p;
        v = q;
    }
    public String toString() {
        return "id = " + id + " " + u + " " + v;
    }
}

class UnionFind {
    int[] id, sz;
    int n;

    public UnionFind(int n) {
        this.n = n;
        id = new int[n];
        sz = new int[n];
        for (int i = 0; i < n; i++) {
            id[i] = i;
            sz[i] = 1;
        }
    }

    private int root(int i) {
        while (i != id[i]) {
            id[i] = id[id[i]];
            i = id[i];
        }
        return i;
    }

    public boolean connected(int u, int v) {
        return root(u) == root(v);
    }

    public void union(int u, int v) {
        int p = root(u);
        int q = root(v);
        if (sz[p] <= sz[q]) {
            id[p] = id[q];
            sz[q] += sz[p];
        } else {
            id[q] = id[p];
            sz[p] += sz[q];
        }
    }
}

class FastReader {
    private boolean finished = false;

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastReader(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 int peek() {
        if (numChars == -1) {
            return -1;
        }
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                return -1;
            }
            if (numChars <= 0) {
                return -1;
            }
        }
        return buf[curChar];
    }

    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 == ',') {
                c = read();
            }
            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 String nextString() {
        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 isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private String readLine0() {
        StringBuilder buf = new StringBuilder();
        int c = read();
        while (c != '\n' && c != -1) {
            if (c != '\r') {
                buf.appendCodePoint(c);
            }
            c = read();
        }
        return buf.toString();
    }

    public String nextLine() {
        String s = readLine0();
        while (s.trim().length() == 0)
            s = readLine0();
        return s;
    }

    public String nextLine(boolean ignoreEmptyLines) {
        if (ignoreEmptyLines) {
            return nextLine();
        } else {
            return readLine0();
        }
    }

    public BigInteger nextBigInteger() {
        try {
            return new BigInteger(nextString());
        } catch (NumberFormatException e) {
            throw new InputMismatchException();
        }
    }

    public char nextCharacter() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        return (char) c;
    }

    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 boolean isExhausted() {
        int value;
        while (isSpaceChar(value = peek()) && value != -1)
            read();
        return value == -1;
    }

    public String next() {
        return nextString();
    }

    public SpaceCharFilter getFilter() {
        return filter;
    }

    public void setFilter(SpaceCharFilter filter) {
        this.filter = filter;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }

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

    public void flush() {
        writer.flush();
    }

}