#include <bits/stdc++.h>
#ifdef dbg
#define D(...) fprintf(stderr, __VA_ARGS__)
#define DD(...) D(#__VA_ARGS__ " = "), debug_helper::debug(__VA_ARGS__), D("\n")
#include "C:\Users\wsyear\Desktop\OI\templates\debug.hpp"
#else
#define D(...) ((void)0)
#define DD(...) ((void)0)
#endif
#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define per(i, j, k) for (int i = (j); i >= (k); --i)
#define SZ(v) int((v).size())
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;

using namespace std;

template <int P>
class mod_int {
  using Z = mod_int;

private:
  static int mo(int x) { return x < 0 ? x + P : x; }

public:
  int x;
  int val() const { return x; }
  mod_int() : x(0) {}
  template <class T>
  mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
  bool operator==(const Z &rhs) const { return x == rhs.x; }
  bool operator!=(const Z &rhs) const { return x != rhs.x; }
  Z operator-() const { return Z(x ? P - x : 0); }
  Z pow(long long k) const {
    Z res = 1, t = *this;
    while (k) {
      if (k & 1) res *= t;
      if (k >>= 1) t *= t;
    }
    return res;
  }
  Z &operator++() {
    x < P - 1 ? ++x : x = 0;
    return *this;
  }
  Z &operator--() {
    x ? --x : x = P - 1;
    return *this;
  }
  Z operator++(int) {
    Z ret = x;
    x < P - 1 ? ++x : x = 0;
    return ret;
  }
  Z operator--(int) {
    Z ret = x;
    x ? --x : x = P - 1;
    return ret;
  }
  Z inv() const { return pow(P - 2); }
  Z &operator+=(const Z &rhs) {
    (x += rhs.x) >= P && (x -= P);
    return *this;
  }
  Z &operator-=(const Z &rhs) {
    (x -= rhs.x) < 0 && (x += P);
    return *this;
  }
  Z &operator*=(const Z &rhs) {
    x = 1ULL * x * rhs.x % P;
    return *this;
  }
  Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                 \
  friend T operator o(const Z &lhs, const Z &rhs) {\
    Z res = lhs;                                   \
    return res o## = rhs;                          \
  }
  setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
};
const int P = 1e9 + 7;
using Z = mod_int<P>;

const int N = 100010;
const int V = 100000;
const int B = 320;
const int inf = 1e9;
const Z iv2 = (P + 1) >> 1;

int mu[N], vis[N];
vector<int> p;
Z sum[N], g[B][B];
map<tuple<int, int, int>, Z> mp;

Z S(int x) {
  return Z(x) * Z(x + 1) * iv2;
}

Z calc(int n, int m) {
  if (n < B && m < B) return g[n][m];
  Z ans = 0;
  for (int l = 1, r; l <= min(n, m); l = r + 1) {
    r = min(n / l ? n / (n / l) : inf, m / l ? m / (m / l) : inf), r = min(r, min(n, m));
    ans += (sum[r] - sum[l - 1]) * S(n / l) * S(m / l);
  }
  return ans;
}

void work() {
  int n, m, a;
  cin >> n >> m >> a;
  if (mp.count({n, m, a})) return cout << mp[{n, m, a}].val() << '\n', void();
  Z ans = 0;
  for (int l = 1, r; l <= a; l = r + 1) {
    r = min(n / l ? n / (n / l) : a, m / l ? m / (m / l) : a), r = min(r, a);
    ans += (S(r) - S(l - 1)) * calc(n / l, m / l);
  }
  mp[{n, m, a}] = ans;
  cout << ans.val() << '\n';
}

void sieve() {
  mu[1] = 1;
  rep (i, 2, V) {
    if (!vis[i]) p.emplace_back(i), mu[i] = -1;
    for (int j : p) {
      if (i * j > V) break;
      vis[i * j] = 1, mu[i * j] = mu[i] * mu[j];
      if (i % j == 0) { mu[i * j] = 0; break; }
    }
  }
  rep (i, 1, V) sum[i] = sum[i - 1] + Z(mu[i]) * i * i;
  rep (i, 1, 319) rep (j, 1, 319) {
    g[i][j] = g[i - 1][j] + g[i][j - 1] - g[i - 1][j - 1];
    if (gcd(i, j) == 1) g[i][j] += Z(i) * j;
  }
}

int main() {
  sieve();
  cin.tie(nullptr) -> ios::sync_with_stdio(false);
  int t; cin >> t;
  while (t--) work();
}