#include <bits/stdc++.h>
#define ADD(a, b) a = (a + ll(b)) % mod
#define MUL(a, b) a = (a * ll(b)) % mod
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define rep(i, a, b) for(int i = int(a); i < int(b); i++)
#define rer(i, a, b) for(int i = int(a) - 1; i >= int(b); i--)
#define all(a) (a).begin(), (a).end()
#define sz(v) (int)(v).size()
#define pb push_back
#define sec second
#define fst first
#define debug(fmt, ...) Debug(__LINE__, ":", fmt, ##__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<int, pi> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> mat;
typedef complex<double> comp;
void Debug() {cerr << '\n'; }
template<class FIRST, class... REST>void Debug(FIRST arg, REST... rest){
	cerr<<arg<<" ";Debug(rest...);}
template<class T>ostream& operator<<(ostream& out,const vector<T>& v) {
	out<<"[";if(!v.empty()){rep(i,0,sz(v)-1)out<<v[i]<<", ";out<<v.back();}out<<"]";return out;}
template<class S, class T>ostream& operator<<(ostream& out,const pair<S, T>& v){
	out<<"("<<v.first<<", "<<v.second<<")";return out;}
const int MAX_N = 500010;
const int MAX_V = 100010;
const double eps = 1e-6;
const ll mod = 1000000007;
const int inf = (1 << 30) - 1;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
mt19937 rng; //use it by rng() % mod, shuffle(all(vec), rng)
///////////////////////////////////////////////////////////////////////////////////////////////////

ll X, Y;
map<ll, ll> DP;


void solve() {
	cin >> X >> Y;
	deque<ll> que;

	DP[Y] = 0;
	que.push_back(Y);

	while(!que.empty()) {
		ll t = que.front(); que.pop_front();
		ll v = DP[t];
		if(t == 0) continue;
		rep(i, -1, 1 + 1) {
			if((t + i) % 2 == 0 && (!DP.count((t + i) / 2) || DP[(t + i) / 2] > v + 1 + abs(i))) {
				DP[(t + i) / 2] = v + 1 + abs(i);
				que.push_back((t + i) / 2);
			}
		}
	}
	ll res = linf;
	for(auto p: DP) {
		// debug(p);
		MIN(res, p.sec + abs(p.fst - X));
	}
	cout << res << "\n";
}

uint32_t rd() {
	uint32_t res;
#ifdef __MINGW32__
	asm volatile("rdrand %0" :"=a"(res) ::"cc");
#else
	res = std::random_device()();
#endif
	return res;
}

int main() {
#ifndef LOCAL
	ios::sync_with_stdio(false);
    cin.tie(0);
#endif
    cout << fixed;
	cout.precision(20);
    cerr << fixed;
	cerr.precision(6);
	rng.seed(rd());
#ifdef LOCAL
	//freopen("in.txt", "wt", stdout); //for tester
	if(!freopen("in.txt", "rt", stdin)) return 1;
#endif	
	solve();
    cerr << "Time: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
	return 0;
}



#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define PB push_back
#define MP make_pair
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define INF (1 << 28)
#define LLINF (1LL << 60)
//#define MOD 998244353
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
using namespace std;
typedef pair<int, int> P;

int main()
{
    int n, m;
    ll a[200005], b[200005];
    vector<int> graph[200005];
    vector<vector<int>> connected;
    bool ischecked[200005] = {}; //false:not checked, true:checked

    cin >> n >> m;
    rep(i, n)
    {
        cin >> a[i];
    }
    rep(i, n)
    {
        cin >> b[i];
    }
    rep(i, m)
    {
        int c, d;
        cin >> c >> d;
        graph[c].push_back(d);
        graph[d].push_back(c);
    }

    for (int i = 1; i <= n; i++)
    {
        vector<int> t_vec;
        queue<int> t_que;
        if (!ischecked[i])
        {
            t_vec.push_back(i);
            ischecked[i] = true;
            rep(j, graph[i].size())
            {
                if (!ischecked[graph[i][j]])
                {
                    t_que.push(graph[i][j]);
                    t_vec.push_back(graph[i][j]);
                    ischecked[graph[i][j]] = true;
                }
            }
            while (!t_que.empty())
            {
                int t = t_que.front();
                t_que.pop();
                rep(j, graph[t].size())
                {
                    if (!ischecked[graph[t][j]])
                    {
                        t_que.push(graph[t][j]);
                        t_vec.push_back(graph[t][j]);
                        ischecked[graph[t][j]] = true;
                    }
                }
            }
            connected.push_back(t_vec);
        }
    }

    bool ans = true;//true:Yes
    for (int i = 0; i < connected.size(); i++)
    {
        ll a_sum = 0, b_sum = 0;
        for (int j = 0; j < connected[i].size();j++){
            a_sum += a[connected[i][j] - 1];
            b_sum += b[connected[i][j] - 1];
        }
        if (a_sum != b_sum)
        {
            ans = false;
        }
    }
    if(ans){
        Yes;
    }
    else{
        No;
    }

        /* cout << endl;
    for (int i = 1; i <= n; i++)
    {
        cout << i << ' ';
        for (int j = 0; j < graph[i].size(); j++)
        {
            cout << graph[i][j] << ' ';
        }
        cout << endl;
    }
    cout << endl;
    rep(i, connected.size())
    {
        cout << i << ' ';
        rep(j, connected[i].size())
        {
            cout << connected[i][j] << ' ';
        }
        cout << endl;
    } */

        return 0;
}
