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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class LehaGame2 {
    
    int N = (int) 3e5 + 10;
    int M = (int) 3e5 + 10;
    
    int n, m;
    int[] d = new int[N];
    int[][][] G;
    
    int cnt;
    boolean[] mark = new boolean[N];
    
    boolean[] vis = new boolean[N];
    boolean[] take = new boolean[M];
    
    void solve() {
        n = in.nextInt();
        m = in.nextInt();
        for (int i = 0; i < n; i++) d[i] = in.nextInt();
        int[] fr = new int[m], to = new int[m], wt = new int[m];
        for (int i = 0; i < m; i++) {
            fr[i] = in.nextInt() - 1;
            to[i] = in.nextInt() - 1;
            wt[i] = i + 1;
        }
        G = build_graph(n, fr, to, wt);
        
        int[] deg = new int[n];
        for (int i = 0; i < m; i++) {
            deg[fr[i]]++;
            deg[to[i]]++;
        }
        
        for (int i = 0; i < n; i++) {
            if (d[i] >= 0 && deg[i] % 2 != d[i]) {
                cnt++;
                mark[i] = true;
            }
        }
        
        if (cnt % 2 == 1) {
            boolean found = false;
            for (int i = 0; i < n; i++) {
                if (d[i] < 0) {
                    found = true;
                    cnt++;
                    mark[i] = true;
                    break;
                }
            }
            if (!found) {
                out.println(-1);
                return;
            }
        }
        
        Arrays.fill(take, true);
        dfs(0);
        
        int ans = 0;
        for (int i = 1; i <= m; i++) if (take[i]) ans++;
        out.println(ans);
        for (int i = 1; i <= m; i++) if (take[i]) out.println(i);
    }
    
    void dfs(int u) {
        vis[u] = true;
        for (int[] p : G[u]) {
            int v = p[0], e = p[1];
            if (!vis[v]) {
                dfs(v);
                if (mark[v]) {
                    take[e] = false;
                    mark[v] = !mark[v];
                    mark[u] = !mark[u];
                }
            }
        }
    }
    
    int[][][] build_graph(int n, int[] from, int[] to, int[] weight) {
        int[][][] G = new int[n][][];
        int[] cnt = new int[n];
        for (int i = 0; i < from.length; i++) {
            cnt[from[i]]++;
            cnt[to[i]]++;
        }
        for (int i = 0; i < n; i++) G[i] = new int[cnt[i]][];
        for (int i = 0; i < from.length; i++) {
            G[from[i]][--cnt[from[i]]] = new int[]{to[i], weight[i]};
            G[to[i]][--cnt[to[i]]] = new int[]{from[i], weight[i]};
        }
        return G;
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new LehaGame2().solve();
        out.close();
    }
    
    static FastScanner in;
    static PrintWriter out;
    
    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;
        
        public FastScanner(BufferedReader in) {
            this.in = in;
        }
        
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        
        public long nextLong() {
            return Long.parseLong(nextToken());
        }
        
        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
