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.*;
import java.util.*;

public class Solution {
  static BufferedReader in;
  static PrintWriter out;
  static StringTokenizer tok = new StringTokenizer("");

  public static void main(String[] args) throws IOException {
    in = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(System.out);
    //in = new BufferedReader(new FileReader("input.txt"));
    solve();
    out.close();
  }

  static String readString() {
    while (!tok.hasMoreTokens()) {
      try {
        tok = new StringTokenizer(in.readLine());
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    return tok.nextToken();
  }

  static int readInt() {
    return Integer.parseInt(readString());
  }

  static double readDouble() {
    return Double.parseDouble(readString());
  }

  static long readLong() {
    return Long.parseLong(readString());
  }


  static List<Edge>[] graph;
  static boolean[] used;
  static int[] parity;
  static int[] dfsParity;
  static boolean[] edgeInAns;
  static int root = 0;

  private static void solve() throws IOException {
    int n = readInt();
    int m = readInt();
    parity = new int[n];
    used = new boolean[n];
    dfsParity = new int[n];
    edgeInAns = new boolean[m];
    graph = new List[n];
    for (int i = 0; i < n; i++) {
      graph[i] = new ArrayList<>();
    }
    for (int i = 0; i < n; i++) {
      parity[i] = readInt();
    }
    for (int i = 0; i < m; i++) {
      int from = readInt() - 1;
      int to = readInt() - 1;
      graph[from].add(new Edge(to, i));
      graph[to].add(new Edge(from, i));
    }
    for (int i = 0; i < n; i++) {
      if (parity[i] == -1) root = i;
    }
    dfs(root, -1);
    if (dfsParity[root] != parity[root] && parity[root] != -1) {
      out.print(-1);
    } else {
      int k = 0;
      for (int i = 0; i < m; i++) {
        if (edgeInAns[i]) k++;
      }
      out.println(k);
      for (int i = 0; i < m; i++) {
        if (edgeInAns[i]) {
          out.println(i + 1);
        }
      }
    }
  }

  private static void dfs(int v, int indexEdgeFrom) {
    used[v] = true;
    if (v != root) {
      edgeInAns[indexEdgeFrom] = true;
      dfsParity[v]++;
    }
    for (Edge edge : graph[v]) {
      if (!used[edge.to]) {
        dfs(edge.to, edge.index);
        dfsParity[v] += dfsParity[edge.to];
        dfsParity[v] %= 2;
      }
    }
    if (v != root && dfsParity[v] != parity[v] && parity[v] != -1) {
      edgeInAns[indexEdgeFrom] = false;
      dfsParity[v]--;
    }
  }

  static class Edge {
    int to, index;

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


}