#include<iostream>
#include<vector>
#include<algorithm>
#include<deque>
#include<cassert>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)

using namespace std;

struct P
{
  int to,cap,rev;
  P(int to=-1,int cap=-1,int rev=-1):to(to),cap(cap),rev(rev){}
};
typedef vector<int> VI;
typedef vector<P> VP;
typedef vector<VP> VVP;
typedef pair<int,int> Pes;
int N,M,s,t; 
VVP G;
vector<int> level,iter;
vector<Pes> vec;
vector<int> pvec;
bool sign;

void add_edge(int from,int to,int i)
{
  if(sign)vec.push_back(Pes(from,G[from].size())),
	    pvec.push_back(i);
  G[from].push_back(P(to,1,G[to].size()));
  G[to].push_back(P(from,0,G[from].size()-1));
}

void bfs()
{
  deque<int> deq;
  deq.push_back(s);
  level[s] = 0;
  while(!deq.empty())
    {
      int p = deq.front(); deq.pop_front();
      rep(i,G[p].size())
	{
	  P pes = G[p][i];
	  int v = pes.to;
	  if(level[v] == -1 && pes.cap > 0)
	    {
	      level[v] = level[p]+1;
	      deq.push_back(v);
	    }
	}
    }
}

int dfs(int v,int flow)
{
  if(v == t)return flow;

  for(int &i = iter[v];i < G[v].size();i++)
    {
      P p = G[v][i];

      if(p.cap <= 0)continue;
      if(level[v] < level[p.to])
	{
	  int d = dfs(p.to,min(flow,p.cap));
	  if(d <= 0)continue;
	  G[v][i].cap -= d;
	  G[p.to][p.rev].cap += d;
	  return d;
	    
	}
    }
  return 0;
}

int maximum_flow()
{
  int res = 0;
  iter.resize(N);
  level.resize(N);
  while(1)
    {
      rep(i,N)
	iter[i] = 0,level[i] = -1;
       bfs();
      
       if(level[t] < 0)return res;
       int f;
  
       while((f = dfs(s,(1<<29))) > 0)
	 res += f;
	 
    }
  return res;
}

int main()
{
  cin >> N >> M;
  G.resize(N);
  rep(i,M)
    {
      int from,to;
      cin >> from >> to;
      from--,to--;
      sign = false;
      add_edge(from,to,i);
      sign = true;
      add_edge(to,from,i);
    }
  cin >> s >> t;
  s--,t--;
  
  int mexico = maximum_flow();
  int cnt = 0;
  rep(i,vec.size())
    {
      int p1 = vec[i].first,p2= vec[i].second;
      if(G[p1][p2].cap != 1)cnt++;
    }

  cout << mexico << endl;
  cout << cnt << endl;
  rep(i,vec.size())
    {
      int p1 = vec[i].first,p2= vec[i].second;
      if(G[p1][p2].cap != 1)
	cout << pvec[i]+1 << endl;
    }

  return 0;
}