#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <set>
#include <sstream>
#include <numeric>
#include <bitset>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cctype>
#include <cassert>
using namespace std;

typedef long long ll;
static const double EPS = 1e-8;
static const double PI = 4.0 * atan(1.0);
bool ISINT(double x){return fabs(x-(int)x)<EPS;}
bool ISEQ(double x,double y){return fabs(x-y)<EPS;}
string itos(ll x){stringstream ss;ss<<x;return ss.str();}
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
#define EREP(i,a,b) for(int i=a;i<=b;i++)
#define erep(i,n) EREP(i,0,n)
#define foreach(itr,c) for(__typeof(c.begin()) itr=c.begin();itr!=c.end();itr++)

#define MAX_V 302
#define INF 999999999

class Edge{
public:
  int to,cap,rev;
  Edge(){}
  Edge(int _to,int _cap,int _rev){
    to = _to;
    cap = _cap;
    rev = _rev;
  }
};

int n,m;
int id[302][302];
vector<Edge> G[MAX_V];
set<int> ans;

void add_edge(int from,int to,int cap){
  G[from].push_back(Edge(to,cap,G[to].size()));
  G[to].push_back(Edge(from,0,G[from].size()-1));
}

int dfs(int v,int t,int f,bool *used){
  if(v == t) return f;
  used[v] = true;
  rep(i,G[v].size()){
    Edge &e = G[v][i];
    if(!used[e.to] && e.cap > 0){
      int d = dfs(e.to,t,min(f,e.cap),used);
      if(d > 0){
        if(id[v][e.to] == -1){
          ans.insert(id[e.to][v]);
        }

        e.cap -= d;
        G[e.to][e.rev].cap += d;
        return d;
      }
    }
  }
  return 0;
}

int max_flow(int s,int t){
  int flow = 0;
  while(1){
    bool used[MAX_V];
    memset(used,0,sizeof(used));
    int f = dfs(s,t,INF,used);
    if(f == 0) return flow;
    flow += f;
  }
}

int main(void){
  while(cin>>n>>m){
    memset(id,-1,sizeof(id));
    rep(i,MAX_V) G[i].clear();
    rep(i,m){
      int a,b;
      cin>>a>>b;
      add_edge(a,b,1);
      add_edge(b,a,1);
      id[a][b] = i+1;
    }
    int s,t;
    cin>>s>>t;
    ans.clear();
    cout<<max_flow(s,t)<<endl;
    cout<<ans.size()<<endl;
    foreach(i,ans){
      cout<<(*i)<<endl;
    }
  }
}