#![allow(unused_imports)]
#![allow(non_snake_case, unused)]

use std::cmp::*;
use std::collections::*;
use std::ops::*;

// https://atcoder.jp/contests/hokudai-hitachi2019-1/submissions/10518254

macro_rules! eprint {
	($($t:tt)*) => {{
		use ::std::io::Write;
		let _ = write!(::std::io::stderr(), $($t)*);
	}};
}
macro_rules! eprintln {
	() => { eprintln!(""); };
	($($t:tt)*) => {{
		use ::std::io::Write;
		let _ = writeln!(::std::io::stderr(), $($t)*);
	}};
}
macro_rules! dbg {
	($v:expr) => {{
		let val = $v;
		eprintln!("[{}:{}] {} = {:?}", file!(), line!(), stringify!($v), val);
		val
	}}
}

macro_rules! mat {
	($($e:expr),*) => { Vec::from(vec![$($e),*]) };
	($($e:expr,)*) => { Vec::from(vec![$($e),*]) };
	($e:expr; $d:expr) => { Vec::from(vec![$e; $d]) };
	($e:expr; $d:expr $(; $ds:expr)+) => { Vec::from(vec![mat![$e $(; $ds)*]; $d]) };
}

macro_rules! ok {
	($a:ident$([$i:expr])*.$f:ident()$(@$t:ident)*) => {
		$a$([$i])*.$f($($t),*)
	};
	($a:ident$([$i:expr])*.$f:ident($e:expr$(,$es:expr)*)$(@$t:ident)*) => { {
		let t = $e;
		ok!($a$([$i])*.$f($($es),*)$(@$t)*@t)
	} };
}

pub fn readln() -> String {
	let mut line = String::new();
	::std::io::stdin().read_line(&mut line).unwrap_or_else(|e| panic!("{}", e));
	line
}

macro_rules! read {
	($($t:tt),*; $n:expr) => {{
		let stdin = ::std::io::stdin();
		let ret = ::std::io::BufRead::lines(stdin.lock()).take($n).map(|line| {
			let line = line.unwrap();
			let mut it = line.split_whitespace();
			_read!(it; $($t),*)
		}).collect::<Vec<_>>();
		ret
	}};
	($($t:tt),*) => {{
		let line = readln();
		let mut it = line.split_whitespace();
		_read!(it; $($t),*)
	}};
}

macro_rules! _read {
	($it:ident; [char]) => {
		_read!($it; String).chars().collect::<Vec<_>>()
	};
	($it:ident; [u8]) => {
		Vec::from(_read!($it; String).into_bytes())
	};
	($it:ident; usize1) => {
		$it.next().unwrap_or_else(|| panic!("input mismatch")).parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1
	};
	($it:ident; [usize1]) => {
		$it.map(|s| s.parse::<usize>().unwrap_or_else(|e| panic!("{}", e)) - 1).collect::<Vec<_>>()
	};
	($it:ident; [$t:ty]) => {
		$it.map(|s| s.parse::<$t>().unwrap_or_else(|e| panic!("{}", e))).collect::<Vec<_>>()
	};
	($it:ident; $t:ty) => {
		$it.next().unwrap_or_else(|| panic!("input mismatch")).parse::<$t>().unwrap_or_else(|e| panic!("{}", e))
	};
	($it:ident; $($t:tt),+) => {
		($(_read!($it; $t)),*)
	};
}


pub fn main() {
	let _ = ::std::thread::Builder::new().name("run".to_string()).stack_size(32 * 1024 * 1024).spawn(run).unwrap().join();
}

const MOD: u32 = 1_000_000_007;
const INF: i64 = std::i64::MAX/3;

#[derive(Copy,Clone)]
struct Edge {
	to: usize,
	cap: i64,
	rev: usize,
}

struct Dinic {
	edge: Vec<Vec<Edge>>,
	level: Vec<i64>,
	iter: Vec<usize>,
	n: usize,
}

impl Dinic {
	pub fn new(n: usize) -> Self {
		Dinic {
			edge: vec![vec![];n],
			level: vec![-1;n],
			iter: vec![0;n],
			n: n,
		}
	}

	pub fn push(&mut self, s: usize, t: usize, c: i64) {
		let mut tmp = self.edge[t].len();
		self.edge[s].push(Edge{to: t, cap: c, rev: tmp});
		let mut tmp = self.edge[s].len();
		self.edge[t].push(Edge{to: s, cap: 0, rev: tmp-1});
	}

	pub fn bfs(&mut self, s: usize) {
		self.level = vec![-1;self.n];
		self.level[s] = 0;
		let mut q = VecDeque::new();
		q.push_back(s);
		while let Some(cur) = q.pop_front() {
			for &e in &self.edge[cur] {
				if e.cap > 0 && self.level[e.to] < 0 {
					self.level[e.to] = self.level[cur] + 1;
					q.push_back(e.to);
				}
			}
		}
	} 

	pub fn dfs(&mut self, v: usize, t: usize, val: i64) -> i64{
		if v==t {
			return val;
		}
		for i in self.iter[v]..self.edge[v].len() {
			let e = self.edge[v][i];
			if e.cap > 0 && self.level[v] < self.level[e.to] {
				let d = self.dfs(e.to,t,min(val,e.cap));
				if d > 0 {
					self.edge[v][i].cap -= d;
					self.edge[e.to][e.rev].cap += d;
					return d;
				}
			}
			self.iter[v] += 1;
		}
		return 0;
	}

	pub fn calc(&mut self, s: usize, t: usize) -> i64{
		let mut flow = 0;
		loop {
			self.bfs(s);
			if self.level[t] < 0 {
				return flow;
			}
			self.iter = vec![0;self.n];
			let mut f = 0;
			loop {
				let ret = self.dfs(s,t,INF);
				if ret == 0 {
					break;
				}
				f += ret;
			}
			flow += f;
		}
	}

}

fn solve() {
	let (n,m) = read!(usize,usize);
	let e = read!(usize,usize,i64;m);
	let mut dinic = Dinic::new(n);
	for (s,t,c) in e {
		dinic.push(s,t,c);
	}
	let val = dinic.calc(0,n-1);
	println!("{}",val);
}

fn run() {
    solve();
}



Measured memory_bytes: 9096