#include <bits/stdc++.h>
using namespace std;

#define for_(i,a,b) for(int i=(a);i<(b);++i)
#define for_rev(i,a,b) for(int i=(a);i>=(b);++i)
#define allof(a) (a).begin(),(a).end()
#define size_of(a) (int)(a).size()
#define minit(a,b) memset(a,b,sizeof(a))

template< typename FLOW >
class Dinic {
private:
	struct Edge { int id, to; FLOW cost; int rev; };
	
	int N;
	vector< vector< Edge > > edges;
	vector< int > level, iter;
	
public:
	Dinic(int n) : N(n), edges(n), level(n, -1), iter(n, 0) {}
	
	void addEdge(int id, int from, int to) {
		edges[from].push_back(Edge{id, to, 1, size_of(edges[to])});
		edges[to].push_back(Edge{0, from, FLOW(), size_of(edges[from]) - 1});
	}
	
	void bfs(int s) {
		fill(allof(level), -1);
		queue< int > que; que.push(s);
		level[s] = 0;
		
		while (!que.empty()) {
			int v = que.front(); que.pop();
			
			for (auto& e : edges[v]) {
				if (e.cost > 0 && level[e.to] < 0) {
					level[e.to] = level[v] + 1;
					que.push(e.to);
				}
			}
		}
	}
	
	FLOW dfs(int v, int t, FLOW f) {
		if (v == t) return f;
		
		int enums = size_of(edges[v]);
		
		for (int& i = iter[v]; i < enums; ++i) {
			Edge& e = edges[v][i];
			
			if (e.cost > 0 && level[v] < level[e.to]) {
				FLOW d = dfs(e.to, t, min(f, e.cost));
				
				if (d > 0) {
					e.cost -= d;
					edges[e.to][e.rev].cost += d;
					return d;
				}
			}
		}
		
		return FLOW(-1);
	}
	
	FLOW maxFlow(int s, int t) {
		FLOW f = FLOW();
		
		while (1) {
			bfs(s);
			
			if (level[t] < 0) return f;
			
			fill(allof(iter), 0);
			FLOW fl;
			while ((fl = dfs(s, t, FLOW(1e9))) > 0) f += fl;
		};
	}
	
	void printAnswer() {
		vector< int > ans;
		
		for_(v,0,N) {
			for (auto& e : edges[v]) {
				if (e.cost == 0 && e.id < 0) ans.push_back(-e.id);
			}
		}
		
		sort(allof(ans));
		int m = size_of(ans);
		cout << m << endl;
		for_(i,0,m) cout << ans[i] << endl;
	}
};

int main() {
	int N, M;
	cin >> N >> M;
	
	Dinic< int > dinic(N);
	
	for_(i,0,M) {
		int u, v;
		cin >> u >> v;
		--u; --v;
		dinic.addEdge(i + 1, u, v);
		dinic.addEdge(-(i + 1), v, u);
	}
	
	int S, T;
	cin >> S >> T;
	--S; --T;
	
	cout << dinic.maxFlow(S, T) << endl;
	dinic.printAnswer();
}