Problem:
Reverse Roads

ICP city has an express company whose trucks run from the crossing S to the crossing T.
The president of the company is feeling upset because all the roads in the city are one-way, and are severely congested.
So, he planned to improve the maximum flow (edge disjoint paths) from the crossing S to the crossing T by reversing the traffic direction on some of the roads.

Your task is writing a program to calculate the maximized flow from S to T by reversing some roads, and the list of the reversed roads.

Input

The first line of a data set contains two integers N (2 \leq N \leq 300) and M (0 \leq M \leq {\rm min} (1\,000,\ N(N-1)/2)).
N is the number of crossings in the city and M is the number of roads.

The following M lines describe one-way roads in the city.
The i-th line (1-based) contains two integers X_i and Y_i (1 \leq X_i, Y_i \leq N, X_i \neq Y_i).
X_i is the ID number (1-based) of the starting point of the i-th road and Y_i is that of the terminal point.
The last line contains two integers S and T (1 \leq S, T \leq N, S \neq T, 1-based).

The capacity of each road is 1.

You can assume that i \neq j implies either X_i \neq X_j or Y_i \neq Y_j,
and either X_i \neq Y_j or X_j \neq Y_i.

Output

In the first line, print the maximized flow by reversing some roads.
In the second line, print the number R of the reversed roads.
In each of the following R lines, print the ID number (1-based) of a reversed road.
You may not print the same ID number more than once.

If there are multiple answers which would give us the same flow capacity, you can print any of them.

Sample Input 1

2 1
2 1
2 1

Output for the Sample Input 1

1
0

Sample Input 2

2 1
1 2
2 1

Output for the Sample Input 2

1
1
1

Sample Input 3

3 3
3 2
1 2
3 1
1 3

Output for the Sample Input 3

2
2
1
3

Solution in C# (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using Debug = System.Diagnostics.Debug;
using SB = System.Text.StringBuilder;
//using System.Numerics;
//using static System.Math;
using C = System.Int32;
namespace Program {
    public class Solver {
        //Random rnd = new Random();
        public void Solve() {
            var n = ri; var m = ri;
            var G = new MaxFlow(n);
            var f = new int[m];
            var t = new int[m];
            for (int i = 0; i < m; i++)
            {
                f[i] = ri - 1;
                t[i] = ri - 1;
                G.AddUndirectedEdge(f[i], t[i], 1);
            }
            var src = ri - 1; var sink = ri - 1;
            var mf = G.Execute(src, sink);
            var ok = new bool[m];
            for (int i = 0; i < n; i++)
                foreach (var e in G.G[i])
                    if (e.Cap == 0)
                    {
                        var u = i;
                        var v = e.To;
                        for (int j = 0; j < m; j++)
                            if (f[j] == u && t[j] == v) ok[j] = true;
                    }
            Console.WriteLine(mf);
            Console.WriteLine(ok.Count(x => !x));
            for (int i = 0; i < m; i++)
                if (!ok[i]) Console.WriteLine(i + 1);
        }
        const long INF = 1L << 60;
        int ri { get { return sc.Integer(); } }
        long rl { get { return sc.Long(); } }
        double rd { get { return sc.Double(); } }
        string rs { get { return sc.Scan(); } }
        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

        static T[] Enumerate<T>(int n, Func<int, T> f) {
            var a = new T[n];
            for (int i = 0; i < n; ++i) a[i] = f(i);
            return a;
        }
        static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
    }
}

#region main
static class Ex {
    /*
    static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
        return string.Join(st, ie);
    }*/
    static public void Main() {
        Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
        var solver = new Program.Solver();
        solver.Solve();
        Console.Out.Flush();
    }
}
#endregion
#region Ex
namespace Program.IO {
    using System.IO;
    using System.Text;
    using System.Globalization;

    public class Printer: StreamWriter {
        public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
        public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
    }

    public class StreamScanner {
        public StreamScanner(Stream stream) { str = stream; }

        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream { get { return isEof; } }

        private byte read() {
            if (isEof) return 0;
            if (ptr >= len)
            {
                ptr = 0;
                if ((len = str.Read(buf, 0, 1024)) <= 0)
                {
                    isEof = true;
                    return 0;
                }
            }
            return buf[ptr++];
        }

        public char Char() {
            byte b = 0;
            do b = read(); while ((b < 33 || 126 < b) && !isEof);
            return (char)b;
        }
        public string Scan() {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
            return sb.ToString();
        }
        public string ScanLine() {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
        public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
        public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
        public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }
}

#endregion
#region MaxFlow
public partial class MaxFlow {
    public readonly List<Edge>[] G;
    readonly int[] lv, iter;
    public MaxFlow(int V) {
        G = new List<Edge>[V];
        lv = new int[V];
        iter = new int[V];
        for (int i = 0; i < G.Length; i++)
            G[i] = new List<Edge>();
    }

    public void AddDirectedEdge(int from, int to, C cap) {
        addEdge(from, to, cap, 0);
    }

    public void AddUndirectedEdge(int from, int to, C cap) {
        addEdge(from, to, cap, cap);
    }
    void addEdge(int f, int t, C c1, C c2) {
        var a = new Edge(t, c1);
        var b = new Edge(f, c2);
        Edge.Link(a, b);
        G[f].Add(a);
        G[t].Add(b);
    }


    public C Execute(int src, int sink, C f = -1) {
        C flow = 0;
        if (f < 0) f = C.MaxValue;
        while (f > 0)
        {
            bfs(src);
            if (lv[sink] == 0) return flow;
            Array.Clear(iter, 0, iter.Length);
            C df;
            while ((df = dfs(src, sink, f)) > 0) { flow += df; f -= df; }
        }
        return flow;
    }

    void bfs(int s) {
        Array.Clear(lv, 0, lv.Length);
        var q = new Queue<int>();
        lv[s] = 1;
        q.Enqueue(s);
        while (q.Count > 0)
        {
            var v = q.Dequeue();
            foreach (var e in G[v])
                if (e.Cap > 0 && lv[e.To] == 0)
                {
                    lv[e.To] = lv[v] + 1;
                    q.Enqueue(e.To);
                }
        }

    }
    C dfs(int v, int t, C f) {
        if (v == t) return f;
        C ret = 0;
        for (; iter[v] < G[v].Count; iter[v]++)
        {
            var e = G[v][iter[v]];
            if (e.Cap <= 0 || lv[v] >= lv[e.To]) continue;
            C df = dfs(e.To, t, Math.Min(f, e.Cap));
            if (df <= 0) continue;
            e.Cap -= df;
            e.Rev.Cap += df;
            ret += df; f -= df;
            if (f == 0) break;
        }
        return ret;

    }
}
public class Edge {
    public static void Link(Edge e1, Edge e2) {
        e1.Rev = e2; e2.Rev = e1;
    }
    public int To { get; private set; }
    public Edge Rev { get; private set; }
    public C Cap { get; set; }
    public Edge(int t, C c) {
        To = t;
        Cap = c;
    }
    public override string ToString() {
        return string.Format("to: {0}, cap: {1}", To, Cap);
    }
}
#endregion