#include <bits/stdc++.h>

using namespace std;

#define DEBUG 1
#define debug if(DEBUG)
#define cdbg debug cerr

const int INF = 1000000000;

struct edge {
    int from, to, cap, flow = 0;
    edge *rev;

    edge() {}
    edge(int from, int to, int cap) : from(from), to(to), cap(cap), rev(nullptr) {}
    edge(int from, int to, int cap, edge *rev) : from(from), to(to), cap(cap), rev(rev) {}
};

int n, m;
vector<edge> e;
vector<vector<int> > g;
vector<int> d, q, ptr;

void addEdge(int u, int v, int c) {
    edge a = edge(u, v, c);
    edge b = edge(v, u, 0, &a);
    a.rev = &b;

    g[u].push_back(e.size());
    e.push_back(a);
    g[v].push_back(e.size());
    e.push_back(b);
}

bool bfs(int s, int t) {
    d.assign(n, -1);
    q.resize(n);
    int qs = 0, qf = 0;
    d[s] = 0;
    q[qf++] = s;
    while(qs < qf) {
        int v = q[qs++];
        for(auto x : g[v]) {
            if(d[e[x].to] == -1 && e[x].flow < e[x].cap) {
                q[qf++] = e[x].to;
                d[e[x].to] = d[v] + 1;
            }
        }
    }
    return d[t] != -1;
}

int dfs(int v, int t, int flow) {
    if(!flow) return 0;
    if(v == t) return flow;
    for(; ptr[v] < g[v].size(); ++ptr[v]) {
        edge *x = &e[g[v][ptr[v]]];
        if(d[x->to] == d[v] + 1) {
            int curflow = dfs(x->to, t, min(flow, x->cap - x->flow));
            if(curflow) {
                x->flow += curflow;
                x->rev->flow -= curflow;
                return curflow;
            }
        }
    }
    return 0;
}

int findFlow(int s, int t) {
    int flow = 0;
    while(bfs(s, t)) {
        ptr.assign(n, 0);
        while(int df = dfs(s, t, INF)) {
            flow += df;
        }
    }
    return flow;
}

int32_t main() {
#ifdef DARKKEKS
    freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
#else
    freopen("flow.in", "r", stdin);
    freopen("flow.out", "w", stdout);
    ios_base::sync_with_stdio(false);
    cin.tie(0);
#endif

    cin >> n >> m;
    g.resize(n);

    int s, t;
    cin >> s >> t;
    s--, t--;

    int u, v, c;
    for(int i = 0; i < m; ++i) {
        cin >> u >> v >> c;
        u--, v--;
        addEdge(u, v, c);
    }

    cout << findFlow(s, t) << "\n";
    for(int i = 0; i < e.size(); i += 2) {
        cout << e[i].flow << "\n";
    }
}