#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <cctype>
#include <tuple>
#include <array>

// BEGIN CUT HERE
#ifdef _MSC_VER
#include <agents.h>
#endif
// END CUT HERE 

#define FOR(i, a, b) for(int i = (int)(a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define REV(v) v.rbegin(), v.rend()
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define MP make_pair
#define MT make_tuple

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

class Flow{
	struct edge{
		int to, rev, cap;
		edge(){}
		edge(int to, int rev, int cap) :to(to), rev(rev), cap(cap){}
	};
	vector<int> used, level, iter;
	int V;
	static const int INF = 1 << 30;
public:
	vector<vector<edge> > Graph;
	Flow(int size) :V(size){
		Graph.resize(V);
		iter.resize(V, 0);
		level.resize(V);
		used.resize(V, 0);
	}
	int add(int from, int to, int cap){
		Graph[from].push_back(edge(to, Graph[to].size(), cap));
		Graph[to].push_back(edge(from, Graph[from].size() - 1, 0));
		return Graph[from].size() - 1;
	}

	/* ford_fulkerson */
	int dfs(int s, int t, int f){
		if (s == t) return f;
		used[s] = 1;
		for (int i = 0; i < Graph[s].size(); i++){
			edge &e = Graph[s][i];
			if (used[e.to] || e.cap <= 0) continue;
			int res = dfs(e.to, t, min(f, e.cap));
			if (res > 0){
				e.cap -= res;
				Graph[e.to][e.rev].cap += res;
				return res;
			}
		}
		return 0;
	}

	int ford_fulkerson(int s, int t){
		int res = 0;
		while (1){
			fill(used.begin(), used.end(), 0);
			int f = dfs(s, t, INF);
			if (!f) break;
			res += f;
		}
		return res;
	}

	/* Dinic */
	void dinic_bfs(int s){
		fill(level.begin(), level.end(), -1);

		queue<int> q;
		q.push(s);
		level[s] = 0;
		while (!q.empty()){
			int v = q.front(); q.pop();
			for (int i = 0; i < Graph[v].size(); i++){
				edge &e = Graph[v][i];
				if (e.cap <= 0 || level[e.to] >= 0) continue;
				level[e.to] = level[v] + 1;
				q.push(e.to);
			}
		}
	}

	int dinic_dfs(int s, int t, int f){
		if (s == t) return f;
		for (int &i = iter[s]; i < Graph[s].size(); i++){
			edge &e = Graph[s][i];
			if (e.cap <= 0 || level[e.to] <= level[s]) continue;
			int res = dinic_dfs(e.to, t, min(f, e.cap));
			if (res > 0){
				e.cap -= res;
				Graph[e.to][e.rev].cap += res;
				return res;
			}
		}
		return 0;
	}

	int dinic(int s, int t){
		int res = 0;
		while (1){
			dinic_bfs(s);
			if (level[t] < 0) break;
			fill(iter.begin(), iter.end(), 0);
			int f;
			while (f = dinic_dfs(s, t, INF)){
				res += f;
			}
		}
		return res;
	}

	int max_flow(int s, int t, bool DINIC = true){
		if (DINIC) return dinic(s, t);
		return ford_fulkerson(s, t);
	}
};

const int M = 1010;
int from[M], idx[M];

int main(){
	int n, m;
	cin >> n >> m;

	Flow f(n);

	rep(i, m){
		int a, b;
		cin >> a >> b;
		--a, --b;
		f.add(a, b, 1);
		from[i] = b;
		idx[i] = f.add(b, a, 1);
	}

	int s, t;
	cin >> s >> t;

	int ans = f.max_flow(s - 1, t - 1);

	vector<int> rev;
	rep(i, m){
		if (f.Graph[from[i]][idx[i]].cap == 0) rev.push_back(i + 1);
	}
	cout << ans << endl;
	cout << rev.size() << endl;
	if (rev.size()){
		for (auto e : rev){
			cout << e << endl;
		}
	}

	return 0;
}

Measured memory_bytes: 1332