public static int bfs(){ 
		int where;
		//	  queue Q
		Queue<Integer> Q = new LinkedList<Integer>();
		//	  push source to Q
		Q.add(sour);
		//	  mark source as visited
		boolean v [] = new boolean[n];
		v[sour] = true;
		//	  keep an array from with the semnification: from[x] is the 
		//	previous vertex visited in the shortest path from the source to x;
		//	initialize from with -1 (or any other sentinel value) 
		int[] from = new int[n];
		Arrays.fill(from, -1);
		//	while Q is not empty
		while( !Q.isEmpty() ){
			//	    where = pop from Q
			where = Q.poll();
			//	    for each vertex next adjacent to where
			for (int i = 0; i < mAdy.length; i++) {
				int next = mAdy[where][i];
				//			if next is not visited and capacity[where][next] > 0
				if( !v[next] && mAdy[where][i] > 0 ){
					//		        push next to Q
					Q.add(next);
					//		        mark next as visited
					v[next] = true;
					//		        from[next] = where
					from[next] = where;
					//		        if next = sink
					if( next == dest )
						break;
				}
				//	    end for
			}
			//	  end while
		}
		int prev;
		// we compute the path capacity
		where = dest; int path_cap = Integer.MAX_VALUE;
		//	  while from[where] > -1
		while( from[where] > -1){
			//	    prev = from[where] // the previous vertex
			prev = from[where];
			//	    path_cap = min(path_cap, capacity[prev][where])
			path_cap = Math.min(path_cap, mAdy[prev][where]);
			where = prev;
			//	  end while
		}
		// we update the residual network; if no path is found the while 
		//	loop will not be entered
		where = dest;
		//	  while from[where] > -1
		while(from[where] > -1){
			prev = from[where];
			mAdy[prev][where] -= path_cap;
			mAdy[where][prev] += path_cap;
			where = prev;
			//	  end while
		}
		// if no path is found, path_cap is infinity
		//	  if path_cap = infinity
		if(path_cap == Integer.MAX_VALUE)
			return 0;
		else return path_cap;
	}