#include <algorithm>
#include <array>
#include <cassert>
#include <iostream>
#include <limits>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;

inline char nc() {
  static char buf[100000], *p1, *p2;
  return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
             ? EOF
             : *p1++;
}
template <class T> inline void read(T &x) {
  x = 0;
  char c = nc();
  while (!isdigit(c))
    c = nc();
  while (isdigit(c))
    x = x * 10 + c - '0', c = nc();
}
template <typename T, typename... Args> inline void read(T &t, Args &...args) {
  read(t);
  read(args...);
}

using index_t = int;

namespace utils {

constexpr index_t LEN_INTERVAL = 7;
constexpr index_t INVALID_INDEX = -1;

class circular_link_list {
  const index_t num_vertex;
  std::vector<index_t> prev, next;
  index_t max_gap_h;

public:
  void reset() {
    max_gap_h = INVALID_INDEX;
    std::fill(prev.begin(), prev.begin() + num_vertex, INVALID_INDEX);
    std::iota(prev.begin() + num_vertex, prev.end(), num_vertex);
    std::fill(next.begin(), next.begin() + num_vertex, INVALID_INDEX);
    std::iota(next.begin() + num_vertex, next.end(), num_vertex);
  }

  bool only_one_node(const index_t h_u) const {
    return next[next[h_u + LEN_INTERVAL + num_vertex]] ==
           h_u + LEN_INTERVAL + num_vertex;
  }

  circular_link_list(const index_t _num_vertex)
      : num_vertex(_num_vertex),
        prev(2 * _num_vertex + LEN_INTERVAL + 1, INVALID_INDEX),
        next(2 * _num_vertex + LEN_INTERVAL + 1, INVALID_INDEX),
        max_gap_h(INVALID_INDEX) {
    std::iota(next.begin() + _num_vertex, next.end(), _num_vertex);
    std::iota(prev.begin() + _num_vertex, prev.end(), _num_vertex);
  };

  void insert(const index_t u, const index_t h_u) {
    if (h_u >= num_vertex + 1 || u >= num_vertex) {
      throw std::runtime_error("超过gap限制");
    }

    if (max_gap_h == INVALID_INDEX || max_gap_h < h_u) {
      max_gap_h = h_u;
    }

    next[u] = next[num_vertex + LEN_INTERVAL + h_u];
    prev[u] = num_vertex + LEN_INTERVAL + h_u;
    prev[next[num_vertex + LEN_INTERVAL + h_u]] = u;
    next[num_vertex + LEN_INTERVAL + h_u] = u;
  }

  void remove(const index_t u) {
    if (u >= num_vertex || next[u] == INVALID_INDEX ||
        prev[u] == INVALID_INDEX) {
      return;
    }
    prev[next[u]] = prev[u];
    next[prev[u]] = next[u];
    next[u] = INVALID_INDEX;
    prev[u] = INVALID_INDEX;
  }

  void refresh_height(index_t *const h_arr, const index_t old_h) {
    for (index_t h = old_h; h <= max_gap_h; h++) {
      index_t first_node = next[h + LEN_INTERVAL + num_vertex];
      for (index_t u = first_node; u < num_vertex; u = next[u]) {
        h_arr[u] = num_vertex + 1;
      }
      while (first_node < num_vertex) {
        index_t to_del = first_node;
        first_node = next[first_node];
        next[to_del] = INVALID_INDEX;
        prev[to_del] = INVALID_INDEX;
      }
      next[h + LEN_INTERVAL + num_vertex] = h + LEN_INTERVAL + num_vertex;
      prev[h + LEN_INTERVAL + num_vertex] = h + LEN_INTERVAL + num_vertex;
    }
    max_gap_h = old_h - 1;
  }
};

class height_queue {
  std::vector<index_t> height_bone;
  std::vector<index_t> next;
  index_t max_h;

public:
  void reset() {
    std::fill(height_bone.begin(), height_bone.end(), INVALID_INDEX);
    std::fill(next.begin(), next.end(), INVALID_INDEX);
    max_h = INVALID_INDEX;
  }

  height_queue(const index_t num_vertex)
      : height_bone(2 * num_vertex, INVALID_INDEX),
        next(num_vertex + 1, INVALID_INDEX), max_h(INVALID_INDEX) {}

  index_t dequeue() {
    while (max_h != INVALID_INDEX && height_bone[max_h] == INVALID_INDEX) {
      max_h--;
    }
    if (max_h == INVALID_INDEX) {
      return INVALID_INDEX;
    }
    index_t to_del = height_bone[max_h];
    height_bone[max_h] = next[to_del];
    return to_del;
  }

  void enqueue(const index_t u, const index_t h_u) {
    if (u >= next.size()) {
      throw std::runtime_error("enqueue 节点编号越界");
    }
    if (h_u >= height_bone.size()) {
      throw std::runtime_error("enqueue 节点高度越界");
    }

    next[u] = height_bone[h_u];
    height_bone[h_u] = u;

    if (max_h == INVALID_INDEX || h_u > max_h) {
      max_h = h_u;
    }
  }
};

}

constexpr index_t MAXN = 1200 + 5;

using flow_amount_t = long long int;

struct HLPP {
  const flow_amount_t INF = numeric_limits<flow_amount_t>::max();
  struct edge {
    index_t to, rev;
    flow_amount_t f;
  };

  index_t maxn, s, t;

  std::vector<edge> edges;
  std::vector<index_t> first_edge;

  utils::height_queue h_que;

  flow_amount_t excess[MAXN];
  std::vector<index_t> arc;

  utils::circular_link_list gap_list;

  std::vector<index_t> height;
  index_t work;


  HLPP(vector<index_t> degrees, index_t s, index_t t)
      : h_que(degrees.size() + 1), gap_list(degrees.size()) {
    this->s = s;
    this->t = t;
    maxn = degrees.size();
    first_edge = std::vector<index_t>(maxn + 1);

    height = std::vector<index_t>(maxn + 1);
    assert(maxn <= MAXN);
    index_t cnt = 0;
    for (index_t i = 0; i < maxn; ++i) {
      first_edge[i] = cnt;
      cnt += degrees[i];
    }
    first_edge[maxn] = cnt;
    edges = std::vector<edge>(cnt);
  }

  void show_all() const {
    for (index_t u = 0; u < maxn; u++) {
      printf("节点%d 🌊%d:[", u + 1, height[u]);
      for (index_t k = first_edge[u]; k < first_edge[u + 1]; k++) {
        printf("🥝%d(%lld) ", edges[k].to + 1, edges[k].f);
      }
      std::cout << ']' << std::endl;
    }
  }

  void addEdge(index_t from, index_t to, flow_amount_t f) {
    static std::vector<index_t> _cur_edge(first_edge);
    edges[_cur_edge[from]] = {to, _cur_edge[to], f};
    edges[_cur_edge[to]] = {from, _cur_edge[from], 0};
    _cur_edge[to]++;
    _cur_edge[from]++;
  }



  void updHeight(index_t v, index_t nh) {
    if (height[v] != maxn) {
      gap_list.remove(v);
    }

    height[v] = nh;
    if (nh == maxn)
      return;

    if (excess[v] > 0) {
      h_que.enqueue(v, nh);
    }

    if (v != s && v != t) {
      gap_list.insert(v, height[v]);
    }
  }

  void globalRelabel() {
    work = 0;
    fill(height.begin(), height.end(), maxn);
    h_que.reset();
    gap_list.reset();
    height[t] = 0;
    std::queue<index_t> que;
    que.push(t);

    while (que.empty() == false) {
      index_t v = que.front();
      que.pop();
      for (index_t ie = first_edge[v]; ie < first_edge[v + 1]; ++ie) {
        auto &e = edges[ie];
        if (height[e.to] == maxn && edges[e.rev].f > 0) {
          que.push(e.to);
          updHeight(e.to, height[v] + 1);
        }
      }
    }
    height[s] = maxn;
  }

  void push(index_t v, edge &e) {
    flow_amount_t df = min(excess[v], e.f);
    if (df > 0) {
      if (excess[e.to] == 0) {
        h_que.enqueue(e.to, height[e.to]);
      }

      e.f -= df, edges[e.rev].f += df;
      excess[v] -= df, excess[e.to] += df;
    }
  }

  void discharge(index_t v) {
    index_t nh = maxn;

    for (index_t i = arc[v]; i < first_edge[v + 1]; i++) {
      auto &e = edges[i];
      if (e.f > 0) {
        if (height[v] == height[e.to] + 1) {
          push(v, e);
          if (excess[v] <= 0) {
            arc[v] = i;
            return;
          }
        } else
          nh = min(nh, height[e.to] + 1);
      }
    }

    for (index_t i = first_edge[v]; i < arc[v]; i++) {
      auto &e = edges[i];
      if (e.f > 0) {
        if (height[v] == height[e.to] + 1) {
          push(v, e);
          if (excess[v] <= 0) {
            arc[v] = i;
            return;
          }
        } else
          nh = min(nh, height[e.to] + 1);
      }
    }

    work++;

    if (gap_list.only_one_node(height[v]) == false) {
      updHeight(v, nh);
    } else {
      gap_list.refresh_height(height.data(), height[v]);

    }
  }

  flow_amount_t calc() {
    for (index_t v = 0; v < maxn; ++v) {
      sort(edges.begin() + first_edge[v], edges.begin() + first_edge[v + 1],
           [](edge &l, edge &r) { return l.to < r.to; });
      for (index_t i = first_edge[v]; i < first_edge[v + 1]; i++) {
        auto &e = edges[i];
        edges[e.rev].rev = i;
      }
    }

    arc = first_edge;
    arc.pop_back();
    fill(excess, excess + maxn, 0);
    excess[s] = INF, excess[t] = -INF;
    globalRelabel();

    for (index_t ie = first_edge[s]; ie < first_edge[s + 1]; ie++)
      push(s, edges[ie]);

    for (index_t u = h_que.dequeue(); u != utils::INVALID_INDEX;
         u = h_que.dequeue()) {
      if (u == s || u == t) {
        continue;
      }
      discharge(u);
      if (work > 4 * maxn)
        globalRelabel();
    }



    return excess[t] + INF;
  }
};

int main(void) {
  index_t n, m, s, t;
  read(n, m, s, t);
  s--;
  t--;
  vector<array<index_t, 3>> input_data;
  input_data.reserve(m);
  vector<index_t> degs(n);
  for (index_t xxx = 1; xxx <= m; xxx++) {
    std::array<index_t, 3> x{};
    read(x[0], x[1], x[2]);
    if (x[0] == x[1]) {
      continue;
    }
    x[0]--, x[1]--;
    ++degs[x[0]];
    ++degs[x[1]];
    input_data.push_back(x);
  }
  HLPP hlpp(degs, s, t);
  for (auto &x : input_data)
    hlpp.addEdge(x[0], x[1], x[2]);
  printf("%lld\n", hlpp.calc());
  return 0;
}