#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using PII=pair<ll,ll>;
queue<PII> q;
// 算法思想：使用map做状态去重，避免重复探索同一(X,Y)状态，防止无限循环
// 优势：天然支持负数、大数，无需边界映射，比固定数组更灵活
map<pair<ll, ll>, bool> a;

void bfs(ll X, ll Y) {
    // 算法思想：BFS初始化，将初始状态入队，标记为已访问
    // BFS的核心是"先进先出"，保证按步骤顺序探索，天然适合寻找"最少操作步骤"
    q.push({X, Y});
    a[{X, Y}] = true;
    ll cnt = 0; // 记录最少操作步骤，对应BFS的遍历层数
    bool found = false; // 标记是否找到目标状态(X==Y)
   
    // 算法思想：设置合理的搜索步骤上限，避免对"永远无法达成目标"的状态无限探索
    // 有效样例的步骤数极少，20步足够覆盖所有可行情况，防止程序卡死
    const int MAX_STEP = 20;

    // 算法思想：BFS主循环，两个终止条件：队列空（无状态可探索）、达到步骤上限（无可行解）
    // 按"层"遍历，每一层对应一步操作，保证步骤数最少
    while (!q.empty() && cnt < MAX_STEP) {
        // 算法思想：记录当前层的节点数，实现BFS的"按层遍历"
        // 每一层对应一次操作步骤，遍历完一层即完成一步，cnt累加一次
        ll size = q.size();
        found = false;

        // 算法思想：遍历当前层的所有状态，逐一处理并生成下一层状态
        for (ll i = 0; i < size; i++) {
            ll x = q.front().first;
            ll y = q.front().second;
            q.pop();

            // 算法思想：目标状态判断，找到即标记并跳出，无需继续探索
            // BFS按层遍历，首次找到的即为"最少步骤"，直接终止即可
            if (x == y) {
                found = true;
                break;
            }

            // 操作1：交换两个数，生成新状态
            // 算法思想：遍历所有合法操作，生成下一层待探索状态，保证状态不遗漏
            ll nx1 = y, ny1 = x;
            if (a.find({nx1, ny1}) == a.end()) { // 判断新状态是否未被访问，避免重复
                a[{nx1, ny1}] = true; // 标记为已访问，防止后续重复入队
                q.push({nx1, ny1}); // 新状态入队，等待下一层遍历（对应下一步操作）
            }

            // 操作2：变换生成(x+y, x-y)，生成新状态
            // 算法思想：遍历所有合法操作，生成下一层待探索状态，保证状态不遗漏
            ll nx2 = x + y, ny2 = x - y;
            if (a.find({nx2, ny2}) == a.end()) { // 判断新状态是否未被访问，避免重复
                a[{nx2, ny2}] = true; // 标记为已访问，防止后续重复入队
                q.push({nx2, ny2}); // 新状态入队，等待下一层遍历（对应下一步操作）
            }
        }

        // 算法思想：当前层找到目标状态，直接跳出循环，停止后续层的探索
        if (found) break;
        // 算法思想：当前层遍历完毕且未找到目标，步骤数+1，进入下一层探索
        // 每一层对应一步操作，cnt累加保证步骤数的准确性（最少步骤）
        cnt++;
    }

    // 算法思想：结果输出，找到目标输出最少步骤，否则输出-1表示无可行解
    if (found) {
        cout << cnt;
    } else {
        cout << -1;
    }
}

int main() {
    ll X,Y;
    cin>>X>>Y;
    // 前置快速判断：初始状态已达标，直接输出0步，避免无用的BFS探索
    if(X==Y){
        cout<<0;
        return 0;
    }

    // 调用BFS进行核心探索，寻找最少操作步骤
    bfs(X,Y);
    return 0;
}