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.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;


public class D {

    static int e = 0;

    public static void add(int v, int u, int[] edges, int[] nextEdge, int[] headEdge) {

        nextEdge[e] = headEdge[v];
        headEdge[v] = e;
        edges[e++] = u;

    }


    public static ArrayList<Integer> solve(int[] d,
                                           int[] edges,
                                           int[] nextEdge,
                                           int[] headEdge
                                           ) {

        boolean[] visited = new boolean[d.length];

        ArrayList<Integer> result = new ArrayList<>(d.length);

        int[] taskV = new int[d.length];
        int[] taskParent = new int[d.length];
        int[] taskEdge = new int[d.length];
        boolean[] solved = new boolean[d.length];

        int tasks = 1;
        taskV[0] = 0;
        visited[0] = true;

        while (tasks > 0) {
            int v = taskV[tasks - 1];
            int edge = taskEdge[tasks - 1];
            int parent = taskParent[tasks - 1];
            boolean allVisited = true;

            if (!solved[v]) {
                solved[v] = true;

                for (int edgeNum = headEdge[v]; edgeNum >= 0; edgeNum = nextEdge[edgeNum]) {
                    int u = edges[edgeNum];

                    if (visited[u])
                        continue;

                    visited[u] = true;
                    allVisited = false;

                    taskV[tasks] = u;
                    taskParent[tasks] = v;
                    taskEdge[tasks] = edgeNum;

                    tasks++;
                }
            }

            if (allVisited) {
                tasks--;
                if (d[v] % 2 == 1) {
                    result.add(edge / 2);
                    d[parent] = d[parent] ^ 1;
                }
            }
        }

        return result;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        int n = scan.nextInt();
        int m = scan.nextInt();

        int[] d = new int[n];

        int[] edges = new int[m*2];
        int[] nextEdge = new int[m * 2];
        int[] headEdge = new int[n];
        Arrays.fill(headEdge, -1);
        Arrays.fill(nextEdge, -1);

        int sum = 0;
        boolean hasNeg = false;
        for (int i = 0; i < n; ++i) {
            d[i] = scan.nextInt();
            if (d[i] == 1)
                sum++;

            if (d[i] == -1)
                hasNeg = true;
        }

        for (int i = 0; i < m; ++i) {
            int u = scan.nextInt() - 1;
            int v = scan.nextInt() - 1;

            add(u, v, edges, nextEdge, headEdge);
            add(v, u, edges, nextEdge, headEdge);
        }

        if (sum % 2== 1 && !hasNeg) {
            System.out.println(-1);
            return;
        }

        for (int i = 0; i < n; ++i) {
            if (d[i] >= 0)
                continue;

            if (sum % 2 == 1) {
                d[i] = 1;
                sum ++;
            }
            else {
                d[i] = 0;
            }
        }

        ArrayList<Integer> result = solve(d, edges, nextEdge, headEdge);

        System.out.println(result.size());
        for (int num : result) {
            System.out.println(num + 1);
        }
    }

}
