#include <iostream>
#include <climits>//需要<climits>来使用INT_MAX
#include <algorithm>
using namespace std;

int solve() {
    int x, y;
    cin >> x >> y;
    int c = x % 10;
    if (c == 0 || c == 5) {
        return 0;
    }

    int a[2] = {0, 5};
    int res = INT_MAX; // 初始化为最大值

    for (int d : a) {
        // x增加操作
        int s1 = (d - c) % 10;
        if (s1 < 0) s1 += 10;

        int dx = x + s1;
        int ops1;
        if (dx <= y) {
            ops1 = s1;
        } else {
            ops1 = s1 + (dx - y);
        }

        // x减少操作
        int s2 = (c - d) % 10;
        if (s2 < 0) s2 += 10;

        int ops2 = INT_MAX; // 初始化为最大值（表示不可行）
        if (x - s2 >= 1) {
            ops2 = s2;
        }

        // 取当前候选值的最小操作次数
        int current_min = min(ops1, ops2);
        // 更新总体最小值
        res = min(res, current_min);
    }

    return res;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        int res = solve();
        cout << res << endl;
    }
    return 0;
}

#include <iostream>
using namespace std;

void solve() {
    int n;
    cin >> n;
    int letter[26];
    for (int i = 0; i < 26; i++) {
        cin >> letter[i];
    }
    string s;
    cin >> s;

    int i = 0;
    while (i < n) {
        char c = s[i];
        int idx = c - 'a';

        // 如果该字母的按键值为0，直接失败
        if (letter[idx] == 0) {
            cout << "No" << endl;
            return;
        }

        // 计算连续相同字母的长度
        int count = 1;
        int j = i + 1;
        while (j < n && s[j] == c) {
            count++;
            j++;
        }

        // 检查长度是否能被letter[idx]整除
        if (count % letter[idx] != 0) {
            cout << "No" << endl;
            return;
        }

        i = j;  // 移动到下一个不同字符的位置
    }

    cout << "Yes" << endl;
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
void solve() {
    int n, k;
    cin >> n >> k;
    //a为原始数组，也就是奇数步的数组
    vector<int>a(n, 0);
    //b为异或后的，是偶数步数组
    vector<int>b(n, 0);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        b[i] = a[i] ^ k;
    }

    //记录整个过程，被移除的元素标记为1
    vector<int> ans(n, 0);

    //创建排序索引
    vector<int> idx_a(n), idx_b(n);
    iota(idx_a.begin(), idx_a.end(), 0);
    iota(idx_b.begin(), idx_b.end(), 0);

    //按原始值的从小到大排序索引
    sort(idx_a.begin(), idx_a.end(), [&](int i, int j) {
        return a[i] < a[j];
    });

    //按异或值的从小到大排序索引
    sort(idx_b.begin(), idx_b.end(), [&](int i, int j) {
        return b[i] < b[j];
    });
    //标记当前未被移除的最小元素索引
    int index_a = 0, index_b = 0;

    //模拟n-1次已出货操作
    for (int i = 0; i < n - 1; i++) {
        if (i % 2 == 0) {
            //偶数步：在异或后的空间中移除最小值
            while (index_b < n && (ans[idx_b[index_b]] == 1))
                index_b++;
            ans[idx_b[index_b]] = 1;
        } else {
            //奇数步：在原始空间中移除最小值
            while (index_a < n && (ans[idx_a[index_a]] == 1))
                index_a++;
            ans[idx_a[index_a]] = 1;
        }
    }

    //找到唯一剩余的元素
    for (int i = 0; i < n; i++) {
        if (ans[i] == 0) {
            if (n % 2)
                cout << a[i] << endl;
            else
                cout << b[i] << endl;
        }
    }
}
int main() {
    solve();
}
// 64 位输出请用 printf("%lld")

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;

// 计算最大公约数
ll gcd(ll a, ll b) {
    while (b) {
        a %= b;
        swap(a, b);
    }
    return a;
}

// 对x进行质因数分解，返回去重后的质因子列表
vector<ll> get_prime(ll x) {
    vector<ll> fact;
    // 1和以下的数没有质因子
    if (x <= 1)
        return fact;
    
    // 单独处理2（唯一的偶质数）
    if (x % 2 == 0) {
        fact.push_back(2);
        while (x % 2 == 0)
            x /= 2;
    }
    
    // 处理奇数质因子
    for (ll i = 3; i * i <= x; i += 2) {
        if (x % i == 0) {
            fact.push_back(i);
            while (x % i == 0)
                x /= i;
        }
    }
    
    // 如果最后x>1，说明x本身就是一个质数
    if (x > 1)
        fact.push_back(x);
    return fact;
}

// 容斥原理计算函数
// primes: k的所有质因子列表
// index: 当前处理的质因子在primes中的索引
// y: 当前剩余的可选数值上限
ll F(const vector<ll>& primes, int index, ll y) {
    // 递归终止条件：已经处理完所有质因子
    if (index == primes.size())
        return 1;  // 返回1表示空选择（数1）
    
    ll res = 0;
    ll current = y;
    
    // 容斥原理的核心循环
    while (current > 0) {
        // 递归处理：不选择当前质因子的情况
        res += F(primes, index + 1, current);
        // 选择当前质因子：将current除以当前质因子
        // 这样下次循环会处理包含当前质因子的情况
        current /= primes[index];
    }
    
    return res;
}

void solve() {
    ll p, q, k;
    cin >> p >> q >> k;
    
    // 移除p中与k共有的质因子
    ll temp = p;
    ll d;
    do {
        d = gcd(temp, k);
        temp /= d;
    } while (d != 1);  // 直到没有公有质因子为止
    
    // 获取k的所有质因子
    vector<ll> primes = get_prime(k);
    
    ll ans = q;  // 初始假设所有分母都对应无限小数
    
    // 获取处理后的p的所有因子
    vector<ll> divs;
    for (ll i = 1; i * i <= temp; i++) {
        if (temp % i == 0) {
            divs.push_back(i);
            if (i != temp / i) {
                divs.push_back(temp / i);
            }
        }
    }
    
    // 对于p的每个因子，应用容斥原理
    for (ll d : divs) {
        if (d > q)  // 如果因子d已经大于q，跳过
            continue;
        
        ll limit = q / d;  // 计算i'的最大可能值
        if (limit == 0)    // 如果limit为0，跳过
            continue;
        
        // 减去满足条件的i'的个数（这些对应有限小数）
        ans -= F(primes, 0, limit);
    }
    
    cout << ans << endl;  // 输出无限小数的个数
}

int main() {
    solve();
    return 0;
}