from functools import cache

MOD = 10 ** 9 + 7

def inv(x):
    return pow(x, MOD - 2, MOD)

@cache
def solve_inv(m):
    if m <= 1:
        return 1

    h = m.bit_length()

    if m >= 3 << (h - 2):
        left = (1 << (h - 1)) - 1
        right = m - left - 1
    else:
        right = (1 << (h - 2)) - 1
        left = m - right - 1

    #print(m, h, left ,right)

    assert left == 0 or left.bit_length() == h - 1
    assert right == 0 or right.bit_length() in [h - 1, h - 2]

    rec = (solve_inv(left) * solve_inv(right)) % MOD
    return (rec * m) % MOD

@cache
def solve(m):
    return inv(solve_inv(m))

@cache
def solve_nan(m):
    if m == 0:
        return []
    elif m == 1:
        return [(0, 1)]

    h = m.bit_length()

    if m >= 3 << (h - 2):
        left = (1 << (h - 1)) - 1
        right = m - left - 1
    else:
        right = (1 << (h - 2)) - 1
        left = m - right - 1

    rec_l = solve(left)
    rec_r = solve(right)
    recn_l = solve_nan(left)
    recn_r = solve_nan(right)

    out = [(m - 1, (rec_l * rec_r % MOD) % MOD)]

    out_l = []
    for u, v in recn_l:
        rec = (v * rec_r) % MOD
        out_l.append((u, (inv(right + left - u) * rec) % MOD))
    out_r = []
    for u, v in recn_r:
        rec = (v * rec_l) % MOD
        out_r.append((u, (inv(right + left - u)  * rec) % MOD))

    while out_l or out_r:
        if len(out_l) == 0:
            out.append(out_r.pop())
        elif len(out_r) == 0 or out_l[-1][0] > out_r[-1][0]:
            out.append(out_l.pop())
        elif out_l[-1][0] < out_r[-1][0]:
            out.append(out_r.pop())
        else:
            u1, v1 = out_l.pop()
            u2, v2 = out_r.pop()

            assert u1 == u2
            out.append((u1, (v1 + v2) % MOD))

    return out[::-1]


t = int(input())
for _ in range(t):
    n = int(input())
    #n = random.randint(1, 10 ** 9)

    out = 0
    for _, v in solve_nan(n):
        out += v

    print(((out % MOD) * inv(n)) % MOD)