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

struct Edge {
    int v, rev;
    long long cap;
};

vector<vector<Edge>> adj;
vector<int> level, ptr;

void add_edge(int u, int v, long long c) {
    adj[u].push_back({v, (int)adj[v].size(), c});
    adj[v].push_back({u, (int)adj[u].size() - 1, 0});
}

bool bfs(int s, int t) {
    level.assign(level.size(), -1);
    queue<int> q;
    q.push(s);
    level[s] = 0;
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (auto &e : adj[u]) {
            if (level[e.v] == -1 && e.cap > 0) {
                level[e.v] = level[u] + 1;
                q.push(e.v);
            }
        }
    }
    return level[t] != -1;
}

long long dfs(int u, int t, long long f) {
    if (u == t) return f;
    for (int &i = ptr[u]; i < (int)adj[u].size(); i++) {
        auto &e = adj[u][i];
        if (level[e.v] == level[u] + 1 && e.cap > 0) {
            long long pushed = dfs(e.v, t, min(f, e.cap));
            if (pushed > 0) {
                e.cap -= pushed;
                adj[e.v][e.rev].cap += pushed;
                return pushed;
            }
        }
    }
    return 0;
}

long long dinic(int s, int t) {
    long long flow = 0;
    level.resize(adj.size());
    ptr.resize(adj.size());
    while (bfs(s, t)) {
        fill(ptr.begin(), ptr.end(), 0);
        while (long long pushed = dfs(s, t, LLONG_MAX)) {
            flow += pushed;
        }
    }
    return flow;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    vector<tuple<int,int,long long>> edges;
    adj.assign(n + 1, {});
    for (int i = 0; i < m; i++) {
        int u, v, c;
        cin >> u >> v >> c;
        edges.push_back({u, v, c});
        add_edge(u, v, c);
    }
    long long base_flow = dinic(s, t);
    vector<int> critical;
    for (int i = 0; i < m; i++) {
        auto [u, v, c] = edges[i];
        adj.assign(n + 1, {});
        for (int j = 0; j < m; j++) {
            auto [a, b, cap] = edges[j];
            long long nc = (j == i) ? cap + 1 : cap;
            add_edge(a, b, nc);
        }
        long long new_flow = dinic(s, t);
        if (new_flow > base_flow) {
            critical.push_back(i + 1);
        }
    }
    cout << critical.size() << "\n";
    for (int i = 0; i < (int)critical.size(); i++) {
        cout << critical[i] << (i + 1 == (int)critical.size() ? "" : " ");
    }
    cout << "\n";
    return 0;
}