#include<bits/stdc++.h>
using namespace std;

struct _int128 {
    unsigned long long low;
    long long high;
    bool sign;
    _int128(): low(0), high(0), sign(1) {}
    _int128(unsigned long long a, long long b, bool c = 1):
        low(a), high(b), sign(c) {}
    _int128(char a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned char a): low(a), high(0), sign(1) {}
    _int128(short a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned short a): low(a), high(0), sign(1) {}
    _int128(int a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned int a): low(a), high(0), sign(1) {}
    _int128(long long a): low(abs(a)), high(0), sign(a >= 0) {}
    _int128(unsigned long long a): low(a), high(0), sign(1) {}
    explicit operator char() {
        return (char)low;
    }
    explicit operator unsigned char() {
        unsigned char res = low;

        if (!sign)
            res = -res;

        return res;
    }
    explicit operator short() {
        return (short)low;
    }
    explicit operator unsigned short() {
        unsigned short res = low;

        if (!sign)
            res = -res;

        return res;
    }
    explicit operator int() {
        return (int)low;
    }
    explicit operator unsigned int() {
        unsigned int res = low;

        if (!sign)
            res = -res;

        return res;
    }
    explicit operator long long() {
        return (long long)low;
    }
    explicit operator unsigned long long() {
        unsigned long long res = low;

        if (!sign)
            res = -res;

        return res;
    }

    _int128 operator= (const _int128 &x) {
        low = x.low, high = x.high, sign = x.sign;
        return (*this);
    }
    bool operator!() const {
        return low == 0 && high == 0;
    }
    bool operator== (const _int128 &y) const {
        auto x = (*this);
        return x.sign == y.sign && x.low == y.low && x.high == y.high;
    }
    bool operator< (const _int128 &y) const {
        auto x = (*this);

        if (x.sign < y.sign)
            return 1;

        if (x.sign > y.sign)
            return 0;

        if (x.high < y.high)
            return 1;

        if (x.high > y.high)
            return 0;

        if (x.low < y.low)
            return 1;

        if (x.low > y.low)
            return 0;

        return 0;
    }
    bool operator<= (const _int128 &y) const {
        auto x = (*this);
        return x < y || x == y;
    }
    bool operator> (const _int128 &y) const {
        auto x = (*this);
        return !(x <= y);
    }
    bool operator>= (const _int128 &y) const {
        auto x = (*this);
        return !(x < y);
    }
    _int128 operator- () {
        auto t = (*this);
        t.sign ^= 1;
        return t;
    }
    _int128 add(_int128 x, _int128 y) {
        auto lo = x.low + y.low;
        auto hi = x.high + y.high;
        hi += lo < x.low;
        return _int128(lo, hi);
    }
    _int128 sub(_int128 x, _int128 y) {
        bool neg = false;

        if (x < y)
            swap(x, y), neg = true;

        auto lo = x.low - y.low;
        auto hi = x.high - y.high;
        hi -= x.low < y.low;
        return _int128(lo, hi, !neg);
    }
    _int128 operator+ (_int128 y) {
        auto x = (*this);

        if (x.sign ^ y.sign) {
            if (x < y)
                swap(x, y);

            return sub(x, y);
        } else {
            auto t = add(x, y);
            t.sign ^= !x.sign;
            return t;
        }
    }
    _int128 operator+= (const _int128 &x) {
        return (*this) = (*this) + x;
    }
    _int128 operator- (_int128 y) const {
        auto x = (*this);
        return x + (-y);
    }
    _int128 operator-= (const _int128 &x) {
        return (*this) = (*this) - x;
    }
    _int128 operator<< (const unsigned long long &y) const {
        auto x = (*this);

        if (y > 128)
            return _int128(0, 0);

        if (y >= 64) {
            return _int128(0, x.low << (y - 64), x.sign);
        } else {
            _int128 res = x;
            unsigned long long t = x.low >> (64 - y);
            res.high = (res.high << y) + t;
            res.low = res.low << y;
            return res;
        }
    }
    _int128 operator<<= (const unsigned long long &y) {
        return (*this) = (*this) << y;
    }
    _int128 operator>> (const unsigned long long &y) const {
        auto x = (*this);

        if (y > 128)
            return _int128(0, 0);

        if (y >= 64) {
            return _int128(x.high >> (y - 64), 0, x.sign);
        } else {
            _int128 res = x;
            unsigned long long t = x.high & ((1ll << y) - 1);
            res.low = (res.low >> y) + (t << (64 - y));
            res.high = res.high >> y;
            return res;
        }
    }
    _int128 operator>>= (const unsigned long long &y) {
        return (*this) = (*this) >> y;
    }
    _int128 operator& (_int128 y) {
        auto x = (*this);

        if (!x.sign)
            x.low = ~x.low, x.high = ~x.high;

        if (!y.sign)
            y.low = ~y.low, y.high = ~y.high;

        return _int128(x.low & y.low, abs(x.high & y.high), x.sign | y.sign);
    }
    _int128 operator| (_int128 y) {
        auto x = (*this);

        if (!x.sign)
            x.low = ~x.low, x.high = ~x.high;

        if (!y.sign)
            y.low = ~y.low, y.high = ~y.high;

        return _int128(x.low | y.low, abs(x.high | y.high), x.sign & y.sign);
    }
    _int128 operator^ (_int128 y) {
        auto x = (*this);

        if (!x.sign)
            x.low = ~x.low, x.high = ~x.high;

        if (!y.sign)
            y.low = ~y.low, y.high = ~y.high;

        return _int128(x.low ^ y.low, abs(x.high ^ y.high), !(x.sign ^ y.sign));
    }
    _int128 operator&= (const _int128 &x) {
        return (*this) = (*this) & x;
    }
    _int128 operator|= (const _int128 &x) {
        return (*this) = (*this) | x;
    }
    _int128 operator^= (const _int128 &x) {
        return (*this) = (*this) ^ x;
    }
    _int128 operator* (const _int128 &y) const {
        auto x = (*this);
        long long H = x.high * y.low + x.low * y.high, L = 0;
        unsigned int LH1 = x.low / (1ll << 32), LH2 = y.low / (1ll << 32);
        unsigned int LL1 = x.low, LL2 = y.low;
        H += (long long)LH1 * LH2, L += (unsigned long long)LL1 * LL2;
        _int128 res = _int128(L, H, !(x.sign xor y.sign));
        res += _int128((unsigned long long)LL1 * LH2) << 32;
        res += _int128((unsigned long long)LH1 * LL2) << 32;
        return res;
    }
    _int128 operator*= (const _int128 &y) {
        return (*this) = (*this) * y;
    }
    _int128 operator/ (_int128 y) const {
        auto x = (*this), z = _int128(1);

        while (y <= x)
            y <<= 1, z <<= 1;

        _int128 res = 0;

        while (y > 0) {
            if (x >= y) {
                x -= y;
                res |= z;
            }

            y >>= 1, z >>= 1;
        }

        res.sign = !(x.sign ^ y.sign);
        return res;
    }
    _int128 operator/= (const _int128 &y) {
        return (*this) = (*this) / y;
    }
    _int128 operator% (const _int128 &y) const {
        auto x = (*this);
        return x - x / y * y;
    }
};
typedef long long ll;
typedef _int128 LLL;
const ll N=3e3+50;
LLL n,a,b,c,m;

LLL read() {
    LLL x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}


void out(LLL x) {
    if (x < 0) putchar('-'), x = -x;
    if (x > 9) out(x / 10);
    putchar((int)(x % 10 + '0'));
}

LLL gcd(LLL x,LLL y){
    return (y==0?x:gcd(y,x%y));
}

LLL lcm(LLL x,LLL y){
    return x/gcd(x,y)*y;
}

int main(){
    n=read();
    
    for(LLL i=1;i<=n;i+=1){
//      scanf("%lld%lld%lld%lld",&m,&a,&b,&c);
        m=read(),a=read(),b=read(),c=read();
        out(m/a-m/lcm(a,b)+m/c-m/lcm(a,c)+m/lcm(lcm(a,b),c));
        printf("\n");
//      printf("%lld\n",m/a-m/lcm(a,b)+m/c-m/lcm(a,c)+m/lcm(lcm(a,b),c));
    }
    
    return 0;
}