#include <iostream>
#include <vector>
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
vector<unsigned int> a,b,c;
static void read(unsigned int& n) {
    n = 0;
	unsigned char ch = getchar();
	while ((ch ^ '0') > 0x9) {ch = getchar();}
	while ((ch ^ '0') < 0xA) {n = n * 0xA + ch - 0x30;ch = getchar();}
}
template <class, class>
inline constexpr bool is_same_v = false; // determine whether arguments are the same type
template <class _Ty>
inline constexpr bool is_same_v<_Ty, _Ty> = true;
template <class _Ty, class... _Types>
inline constexpr bool _Is_any_of_v = (is_same_v<_Ty, _Types> || ...);
template <class _Ty>
inline constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char, signed char, unsigned char,wchar_t,char16_t, char32_t, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>;
template <class _UInt>
inline constexpr int _Unsigned_integer_digits = sizeof(_UInt) * 8;
template <class _Ty>
inline constexpr bool _Is_nonbool_integral = is_integral_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>;
template <class _Ty, bool = is_integral_v<_Ty>>
struct _Sign_base { // determine whether integral type _Ty is signed or unsigned
    using _Uty = remove_cv_t<_Ty>;

    static constexpr bool _Signed   = static_cast<_Uty>(-1) < static_cast<_Uty>(0);
    static constexpr bool _Unsigned = !_Signed;
};
template <class _Ty>
inline constexpr bool is_signed_v = _Sign_base<_Ty>::_Signed;
template <class _Ty>
[[nodiscard]] constexpr int _Countl_zero_fallback(_Ty _Val) noexcept {
    _Ty _Yx = 0;

    unsigned int _Nx = _Unsigned_integer_digits<_Ty>;
    unsigned int _Cx = _Unsigned_integer_digits<_Ty> / 2;
    do {
        _Yx = static_cast<_Ty>(_Val >> _Cx);
        if (_Yx != 0) {
            _Nx -= _Cx;
            _Val = _Yx;
        }
        _Cx >>= 1;
    } while (_Cx != 0);
    return static_cast<int>(_Nx) - static_cast<int>(_Val);
}
template <class _Ty>
[[nodiscard]] constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept {
    constexpr int _Digits = _Unsigned_integer_digits<_Ty>;
    return _Digits - _Countl_zero_fallback(static_cast<_Ty>(static_cast<_Ty>(~_Val) & static_cast<_Ty>(_Val - 1)));
}
template <class _Ty, class _Fn>
constexpr decltype(auto) _Select_countr_zero_impl(_Fn _Callback) {
    return _Callback([](_Ty _Val) { return _Countr_zero_fallback(_Val); });
}
template <class _Integral>
[[nodiscard]] constexpr auto _Abs_u(const _Integral _Val) noexcept {
    static_assert(is_integral_v<_Integral>);
    if constexpr (is_signed_v<_Integral>) {
        using _Unsigned = make_unsigned_t<_Integral>;
        if (_Val < 0) {
            return static_cast<_Unsigned>(_Unsigned{ 0 } - static_cast<_Unsigned>(_Val));
        }
        return static_cast<_Unsigned>(_Val);
    }
    else {
        return _Val;
    }
}
template <class _Mt, class _Nt>
[[nodiscard]] constexpr common_type_t<_Mt, _Nt> gcd(const _Mt _Mx, const _Nt _Nx) noexcept /* strengthened */ {
    // calculate greatest common divisor
    static_assert(_Is_nonbool_integral<_Mt> && _Is_nonbool_integral<_Nt>, "GCD requires nonbool integral types");

    using _Common = common_type_t<_Mt, _Nt>;
    using _Common_unsigned = make_unsigned_t<_Common>;

    return _Select_countr_zero_impl<_Common_unsigned>([=](auto _Countr_zero_impl) {
        _Common_unsigned _Mx_magnitude = _Abs_u(_Mx);
        _Common_unsigned _Nx_magnitude = _Abs_u(_Nx);
        if (_Mx_magnitude == 0U) {
            return static_cast<_Common>(_Nx_magnitude);
        }

        if (_Nx_magnitude == 0U) {
            return static_cast<_Common>(_Mx_magnitude);
        }

        const auto _Mx_trailing_zeroes = static_cast<unsigned long>(_Countr_zero_impl(_Mx_magnitude));
        auto _Nx_trailing_zeroes = static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude));
        const auto _Common_factors_of_2 = (::std::min)(_Mx_trailing_zeroes, _Nx_trailing_zeroes);
        _Mx_magnitude >>= _Mx_trailing_zeroes;
        for (;;) {
            _Nx_magnitude >>= _Nx_trailing_zeroes;
            if (_Mx_magnitude > _Nx_magnitude) {
                _Common_unsigned _Temp = _Mx_magnitude;
                _Mx_magnitude = _Nx_magnitude;
                _Nx_magnitude = _Temp;
            }

            _Nx_magnitude -= _Mx_magnitude;
            if (_Nx_magnitude == 0U) {
                return static_cast<_Common>(_Mx_magnitude << _Common_factors_of_2);
            }
            _Nx_trailing_zeroes = static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude));
        }
    });
}

没错，直接从MSVC标准库偷来的gcd

本地能过（我用的甚至是GCC8.1）

洛谷就不行了（C++20,C++17都试过了）