// Ý tưởng:
// Dùng BFS để duyệt qua các trạng thái từ n.
// Nếu gặp u thì dừng.
// Code mẫu (chỉ mang tính minh họa, không chạy được do giới hạn bộ nhớ):
#include <iostream>
#include <queue>
#include <set>
using namespace std;

int main() {
    long long n, u;
    cin >> n >> u;
    if (n >= u) {
        cout << u - n;
        return 0;
    }
    queue<pair<long long, int>> q;
    q.push({n, 0});
    set<long long> visited;
    visited.insert(n);
    while (!q.empty()) {
        auto [curr, steps] = q.front();
        q.pop();
        if (curr == u) {
            cout << steps;
            return 0;
        }
        // Phép nhân đôi
        if (curr * 2 <= u * 2 && visited.find(curr * 2) == visited.end()) {
            visited.insert(curr * 2);
            q.push({curr * 2, steps + 1});
        }
        // Phép cộng 1
        if (curr + 1 <= u * 2 && visited.find(curr + 1) == visited.end()) {
            visited.insert(curr + 1);
            q.push({curr + 1, steps + 1});
        }
    }
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    long long n, u;
    cin >> n >> u;

    if (n >= u) {
        cout << u - n << endl;
        return 0;
    }

    long long steps = 0;
    // Tăng n lên bằng phép nhân đôi khi còn nhỏ hơn u
    while (n < u) {
        n *= 2;
        steps++;
    }

    // Khi này n đã >= u.
    // Nếu n == u, ta có đáp án.
    // Nếu n > u, ta lùi lại một bước nhân đôi và cộng thêm số lượng bước cộng 1.
    // Tuy nhiên, cách này vẫn chưa hoàn toàn tối ưu cho các bài toán khó,
    // nhưng với ràng buộc bài này, ta có thể dùng cách sau của Solution 2:
    // 
    // Solution 2 thực chất là:
    // 1. Dùng phép nhân đôi tối đa có thể sao cho sau khi nhân đôi, giá trị <= u.
    // 2. Sau đó dùng phép cộng 1 để bù vào phần còn thiếu.

    // Viết lại theo Solution 2:
    long long cnt = 0;
    // Điều kiện 2 * n <= u đảm bảo n sau khi nhân đôi không vượt quá u
    while (2 * n <= u) {
        n *= 2;
        cnt++;
    }
    // Sau vòng lặp, n là số lớn nhất có thể đạt được bằng phép nhân đôi mà không vượt quá u.
    // Bây giờ dùng phép cộng 1 để đi đến u.
    cnt += (u - n);

    cout << cnt;
    return 0;
}

// Solution 1 thể hiện ý tưởng này:
#include <iostream>
using namespace std;

int main() {
    long long n, u;
    cin >> n >> u;
    if (n >= u) {
        cout << u - n;
        return 0;
    }
    // Case 2: u/n == 1. Tức là n rất gần u (n < u < 2n).
    // Khi đó không nên nhân đôi (vì sẽ vượt u), chỉ dùng cộng 1.
    else if (u / n == 1) {
        cout << u - n;
        return 0;
    }
    else {
        long long dem = 0;
        long long tmp;
        // Vòng lặp này thực chất là nhân đôi cho đến khi vượt quá u
        while (n < u) {
            tmp = n; // Lưu lại giá trị trước khi nhân đôi
            n += n; // Nhân đôi
            ++dem;
        }
        if (n == u) {
            cout << dem;
        }
        else {
            // Nếu n > u:
            // Ý tưởng là: Ta đã thực hiện `dem` lần nhân đôi và vượt quá u.
            // Lùi lại 1 bước nhân đôi (giảm `tmp` ra).
            // N lúc này là `tmp` (hoặc `n - tmp` là phần vượt trội).
            // Thực tế, ta có thể chia nhỏ các bước.
            // Tuy nhiên, code này có vẻ chưa hoàn toàn đúng với logic backtracking tổng quát,
            // nhưng về cơ bản nó tìm cách lùi lại và cộng.
            // Code giải thích:
            // cout << (dem-1) + (u-n); // Logic này có vẻ sai trong một số trường hợp.
            // Thay vào đó, logic của Solution 2 là chuẩn hơn.
            // Tuy nhiên, để minh họa ý tưởng "tối ưu hóa", ta có thể dùng đệ quy hoặc quy hoạch động
            // nhưng với $10^{18}$ thì chỉ cần toán học là đủ.
        }
    }
    return 0;
}