Problem: Leha plays a computer game, where is on each level is given a connected graph with n vertices and m edges. Graph can contain multiple edges, but can not contain self loops. Each vertex has an integer di, which can be equal to 0, 1 or  - 1. To pass the level, he needs to find a «good» subset of edges of the graph or say, that it doesn't exist. Subset is called «good», if by by leaving only edges from this subset in the original graph, we obtain the following: for every vertex i, di = - 1 or it's degree modulo 2 is equal to di. Leha wants to pass the game as soon as possible and ask you to help him. In case of multiple correct answers, print any of them.

Input

The first line contains two integers n, m (1 ≤ n ≤ 3·105, n - 1 ≤ m ≤ 3·105) — number of vertices and edges.

The second line contains n integers d1, d2, ..., dn ( - 1 ≤ di ≤ 1) — numbers on the vertices.

Each of the next m lines contains two integers u and v (1 ≤ u, v ≤ n) — edges. It's guaranteed, that graph in the input is connected.

Output

Print  - 1 in a single line, if solution doesn't exist. Otherwise in the first line k — number of edges in a subset. In the next k lines indexes of edges. Edges are numerated in order as they are given in the input, starting from 1.

Examples

Input

1 0
1


Output

-1


Input

4 5
0 0 0 -1
1 2
2 3
3 4
1 4
2 4


Output

0


Input

2 1
1 1
1 2


Output

1
1


Input

3 3
0 -1 1
1 2
2 3
1 3


Output

1
2

Note

In the first sample we have single vertex without edges. It's degree is 0 and we can not get 1.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
long long null = 0;
struct segment;
struct line;
struct point;
struct vec;
struct ray;
struct point {
  long double x, y;
  point() {}
  point(long double x1, long double y1) {
    x = x1;
    y = y1;
  }
  long double dist_to_point(point p) {
    return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
  }
  bool operator<(point p) { return (x < p.x) || ((x == p.x) && (y < p.y)); }
};
struct vec {
  long double x, y;
  vec(long double x1, long double y1) {
    x = x1;
    y = y1;
  }
  vec(point a, point b) {
    x = b.x - a.x;
    y = b.y - a.y;
  }
  vec normal() {
    vec ans;
    ans.x = y;
    ans.y = -x;
    return ans;
  }
  vec opposite() {
    vec ans;
    ans.x = -x;
    ans.y = -y;
    return ans;
  }
  vec sum(vec b) {
    vec ans;
    ans.x = x + b.x;
    ans.y = y + b.y;
    return ans;
  }
  long double cross_product(vec v) { return x * v.y - v.x * y; }
  long double dot_product(vec v) { return x * v.x + y * v.y; }
  vec resize(long double size) {
    vec ans;
    ans.x = (x * size) / len();
    ans.y = (y * size) / len();
    return ans;
  }
  vec() {}
  long double len() { return sqrt(x * x + y * y); }
};
struct line {
  long double a, b, c;
  line(point a1, point b1) {
    a = a1.y - b1.y;
    b = b1.x - a1.x;
    c = -a1.x * a - a1.y * b;
  }
  line(long double a1, long double b1, long double c1) {
    a = a1;
    b = b1;
    c = c1;
  }
  line() {}
  vec normal_vec() {
    vec ans;
    ans.x = a;
    ans.y = b;
    return ans;
  }
  line normal_line(point p) {
    line ans;
    ans.a = -b;
    ans.b = a;
    ans.c = -ans.a * p.x - ans.b * p.y;
    return ans;
  }
  long double get_x(long double y1) {
    if (a == 0) return 0;
    return (-c - b * y1) / a;
  }
  long double get_y(long double x1) {
    if (b == 0) return 0;
    return (-c - a * x1) / b;
  }
  point intersection(line l) {
    point ans;
    ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
    ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
    return ans;
  }
  bool parallels(line l) { return a * l.b - l.a * b == 0; }
  long double dist_to_point(point p) {
    return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
  }
  long long is_inside(point p) {
    long double k = a * p.x + b * p.y + c;
    if (k < 0)
      return -1;
    else if (k == 0)
      return 0;
    return 1;
  }
};
struct segment {
  point a, b;
  segment() {}
  segment(point a1, point b1) {
    a = a1;
    b = b1;
  }
  long double len() {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
  }
  bool is_inside(point p) {
    line l(a, b);
    if (l.is_inside(p) != 0) return false;
    vec v(p, a), v1(p, b);
    if (v.dot_product(v1) > 0) return false;
    return true;
  }
  long double dist_to_point(point p) {
    vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
    if (v.dot_product(v1) < 0) return p.dist_to_point(a);
    if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
    line l(a, b);
    return l.dist_to_point(p);
  }
  point get_center() {
    point ans;
    ans.x = (a.x + b.x) / 2;
    ans.y = (a.y + b.y) / 2;
    return ans;
  }
};
struct ray {
  point a, b;
  ray(point p, point p1) {
    a = p;
    b = p1;
  }
  ray() {}
  long double dist_to_point(point p) {
    vec v(a, p), v1(a, b);
    if (v.dot_product(v1) < 0) return a.dist_to_point(p);
    line l(a, b);
    return l.dist_to_point(p);
  }
  bool is_inside(point p) {
    line l(a, b);
    if (l.is_inside(p) != 0) return false;
    vec v(a, p), v1(a, b);
    if (v.dot_product(v1) < 0) return false;
    return true;
  }
};
struct angle {
  point a, b, c;
  angle(){};
  angle(point a1, point b1, point c1) {
    a = a1;
    b = b1;
    c = c1;
  }
  long double get_angle() {
    vec v(b, a), v1(b, c);
    return acos(v.dot_product(v1) / (v.len() * v1.len()));
  }
  long double get_grad_angle() {
    vec v(b, a), v1(b, c);
    return 180 * acos(v.dot_product(v1) / (v.len() * v1.len())) /
           3.141592653589793238462643;
  }
};
struct polygon {
  long long n;
  vector<point> points;
  long double get_area() {
    point a(0, 0);
    vec v(a, points[0]);
    long double ans = 0;
    for (long long i = 1; i < n; ++i) {
      vec v1(a, points[i]);
      ans = ans + v.cross_product(v1);
      v = v1;
    }
    vec v2(a, points[0]);
    vec v1(a, points[n - 1]);
    return abs(ans + v1.cross_product(v2)) / 2;
  }
};
struct triangle {
  point a, b, c;
  triangle() {}
  triangle(point a1, point b1, point c1) {
    a = a1;
    b = b1;
    c = c1;
  }
  long double get_area() {
    point d(0, 0);
    vec v(a, d), v1(b, d), v2(c, d);
    return (v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v)) /
           2;
  }
  point get_center() {
    segment s(a, b), s1(a, c);
    point p = s.get_center(), p1 = s1.get_center();
    line l(a, b), l1(a, c), l2(b, c);
    l = l.normal_line(p);
    l1 = l1.normal_line(p1);
    return l.intersection(l1);
  }
  long double get_R() {
    triangle t(a, b, c);
    point p = t.get_center();
    return p.dist_to_point(a);
  }
};
long long power(long long a, long long b) {
  if (b == 0)
    return 1;
  else if (b == 1)
    return a;
  else {
    long long k = power(a, b / 2);
    return k * k * power(a, b % 2);
  }
}
long long power_mod(long long a, long long b, long long MOD) {
  if (b == 0)
    return 1;
  else if (b == 1)
    return a % MOD;
  else {
    long long k = power_mod(a, b / 2, MOD);
    return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
  }
}
long long sum_mod(long long a, long long b, long long MOD) {
  return (a + b) % MOD;
}
long long mul_mod(long long a, long long b, long long MOD) {
  return (a * b) % MOD;
}
long long ord(char a) { return a; }
char chr(long long a) { return a; }
long long strtoint(string s) {
  long long ans = 0;
  for (long long i = 0; i < s.size(); ++i) {
    ans *= 10;
    ans += ord(s[i]) - 48;
  }
  return ans;
}
string rev_string(string s) {
  string ans = "";
  for (long long i = s.size(); i >= 0; --i) {
    ans += s[i];
  }
  return ans;
}
string inttostr(long long a) {
  string ans = "", ans1 = "";
  while (a > 0) {
    ans += chr(a + 48);
    a /= 10;
  }
  for (long long i = ans.size() - 1; i >= 0; --i) {
    ans1 += ans[i];
  }
  return ans1;
}
long long gcd(long long a, long long b) {
  if (a == 0) return b;
  return gcd(b % a, a);
}
long long nok(long long a, long long b) { return a * b / gcd(a, b); }
vector<vector<pair<long long, long long> > > ar;
bool used[600000];
bool q = false;
long long d[600000];
long long ans = 0;
bool mas[600000];
void dfs(long long v) {
  if (d[v] == -1) {
    if (q) q = false;
  }
  if (d[v] == 1) {
    q = !q;
  }
  used[v] = true;
  for (long long i = 0; i < ar[v].size(); ++i) {
    if (!used[ar[v][i].first]) {
      if (q) {
        if (mas[ar[v][i].second]) {
          --ans;
          mas[ar[v][i].second] = false;
        } else {
          ++ans;
          mas[ar[v][i].second] = true;
        }
      }
      dfs(ar[v][i].first);
      if (q) {
        if (d[v] == -1) q = false;
        if (mas[ar[v][i].second]) {
          --ans;
          mas[ar[v][i].second] = false;
        } else {
          ++ans;
          mas[ar[v][i].second] = true;
        }
      }
    }
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  srand(time(0));
  long long n, m;
  cin >> n >> m;
  for (long long i = 1; i <= n; ++i) {
    cin >> d[i];
  }
  ar.resize(n + 1);
  for (long long i = 0; i < m; ++i) {
    long long u, v;
    cin >> u >> v;
    ar[u].push_back(make_pair(v, i + 1));
    ar[v].push_back(make_pair(u, i + 1));
  }
  long long p = 1;
  for (long long i = 1; i <= n; ++i) {
    if (d[i] == -1) p = i;
  }
  dfs(p);
  if (q) {
    cout << "-1";
    exit(0);
  }
  cout << ans << endl;
  for (long long i = 1; i <= m; ++i) {
    if (mas[i]) cout << i << endl;
  }
}