#include<bits/stdc++.h>
#include<atcoder/all>
using namespace std;
namespace my{
using ml=atcoder::modint1000000007;
auto&operator>>(istream&i,ml&x){int t;i>>t;x=t;return i;}
auto&operator<<(ostream&o,const ml&x){return o<<(int)x.val();}
#define eb emplace_back
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define FO(n) for(ll ij=n;ij-->0;)
#define FOR(i,...) for(auto[i,i##stop,i##step]=range(0,__VA_ARGS__);i<i##stop;i+=i##step)
#define fo(i,...) FO##__VA_OPT__(R)(i __VA_OPT__(,__VA_ARGS__))
#define of(i,...) for(auto[i,i##stop,i##step]=range(1,__VA_ARGS__);i>=i##stop;i+=i##step)
#define fe(a,i,...) for(auto&&__VA_OPT__([)i __VA_OPT__(,__VA_ARGS__]):a)
#define bit_sizeof(T) ll(sizeof(T)*CHAR_BIT)
#define base_operator(op,type) auto operator op(const type&v)const{auto copy=*this;return copy op##=v;}
#define multiple_testcases void solve();}int main(){my::io();int T;std::cin>>T;while(T--)my::solve();}namespace my{
void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<<fixed<<setprecision(15);}
using ll=long long;
constexpr auto range(ll s,ll b){ll a=0;if(s)swap(a,b);return array{a-s,b,1-s*2};}
constexpr auto range(ll s,ll a,ll b,ll c=1){return array{a-s,b,(1-s*2)*c};}
constexpr char newline=10;
constexpr char space=32;
constexpr auto schrodinger(bool p,char c){return string(p,c);}
constexpr auto schrodinger(bool p,auto c){return p*c;}
constexpr auto square(auto x){return x*x;}
template<class T>concept addable=requires(T a,T b){{a+b}->same_as<T>;};

template<class A,class B>struct pair{
  A a;B b;
  pair()=default;
  pair(A a,B b):a(a),b(b){}
  pair(const std::pair<A,B>&p):a(p.first),b(p.second){}
  auto operator<=>(const pair&)const=default;
  pair operator+(const pair&p)const{return{a+p.a,b+p.b};}
  friend istream&operator>>(istream&i,pair&p){return i>>p.a>>p.b;}
  friend ostream&operator<<(ostream&o,const pair&p){return o<<p.a<<space<<p.b;}
};

template<ll k,class...A>using pack_kth_t=tuple_element_t<k,std::tuple<A...>>;
template<ll k>auto pack_kth(const auto&...a){return get<k>(make_tuple(a...));}
template<class T,ll n>auto pack_prefix_array(const auto&...a){return[&]<size_t...I>(index_sequence<I...>){return array<T,n>{get<I>(make_tuple(a...))...};}(make_index_sequence<n>{});}

template<class V>concept vectorial=is_base_of_v<vector<typename V::value_type>,V>;
template<class T>struct vec_attr{using core_type=T;static constexpr int rank=0;};
template<vectorial V>struct vec_attr<V>{using core_type=typename vec_attr<typename V::value_type>::core_type;static constexpr int rank=vec_attr<typename V::value_type>::rank+1;};
template<class V>istream&operator>>(istream&i,vector<V>&v){fe(v,e)i>>e;return i;}
template<class V>ostream&operator<<(ostream&o,const vector<V>&v){fe(v,e)o<<e<<schrodinger(&e!=&v.back(),vectorial<V>?newline:space);return o;}

template<class V>struct vec;
template<int rank,class T>struct tensor_helper{using type=vec<typename tensor_helper<rank-1,T>::type>;};
template<class T>struct tensor_helper<0,T>{using type=T;};
template<int rank,class T>using tensor=typename tensor_helper<rank,T>::type;

template<class V>struct vec:vector<V>{
  static constexpr int R=vec_attr<V>::rank+1;
  using C=vec_attr<V>::core_type;
  using vector<V>::vector;
  vec(const vector<V>&v){vector<V>::operator=(v);}

  template<class...A>requires(sizeof...(A)>=3)vec(const A&...a){resizes(pack_prefix_array<ll,R>(a...),pack_kth<R>(a...));}
  void resizes(const array<ll,R>&s,C x={}){*this=std::move(make(s,x));}
  template<ll i=0>static auto make(const array<ll,R>&s,C x){if constexpr(i==R-1)return vec<C>(s[i],x);else return tensor<R-i,C>(s[i],make<i+1>(s,x));}

  vec&operator^=(const vec&u){this->insert(this->end(),u.begin(),u.end());return*this;}
  vec&operator+=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]+=u[i];return v;}
  vec&operator-=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]-=u[i];return v;}
  base_operator(^,vec)
  base_operator(+,vec)
  base_operator(-,vec)

  vec&operator--(){fe(*this,e)--e;return*this;}

  ll size()const{return vector<V>::size();}

  vec zeta()const{vec v=*this;if constexpr(vectorial<V>)fe(v,e)e=e.zeta();fo(i,v.size()-1)v[i+1]+=v[i];return v;}

  auto transform(const auto&f)const{
    tensor<R,decltype(f(C{}))>res(size());
    if constexpr(vectorial<V>)fo(i,size())res[i]=(*this)[i].transform(f);
    else std::transform(this->begin(),this->end(),res.begin(),f);
    return res;
  }

  template<class T>auto cast_core_type()const{return transform([&](auto e){return static_cast<T>(e);});}
};
template<class...A>requires(sizeof...(A)>=2)vec(const A&...a)->vec<tensor<sizeof...(A)-2,pack_kth_t<sizeof...(A)-1,A...>>>;
vec(ll)->vec<ll>;

void lin(auto&...a){(cin>>...>>a);}
void pp(const auto&...a){ll n=sizeof...(a);((cout<<a<<schrodinger(--n>0,space)),...);cout<<newline;}

auto iota_lambda(ll n,const auto&f){vec<decltype(f(0))>r(n);fo(i,n)r[i]=f(i);return r;}

constexpr uint64_t kth_root_floor(uint64_t a,ll k){
  if (k==1)return a;
  auto within=[&](uint32_t x){uint64_t t=1;fo(k)if(__builtin_mul_overflow(t,x,&t))return false;return t<=a;};

  uint64_t r=0;
  of(i,bit_sizeof(uint32_t))if(within(r|(1u<<i)))r|=1u<<i;
  return r;
}
template<class T>constexpr T sqrt_floor(T x){return kth_root_floor(x,2);}

auto divmod(auto a,auto b){return pair{a/b,a%b};}
auto mod(auto a,auto b){return(a%=b)<0?a+b:a;}

template<class T>T square_sum(T n){return n*(n+1)/2*(n*2+1)/3;}

template<class T>T square_sum(const vec<ll>&a){
  T res=0;
  fe(a,e)res+=T(e)*e;
  return res;
}

template<class T>struct circle_vec:vec<T>{
  vec<T>su;
  circle_vec(ll n):vec<T>(n){}
  circle_vec(const initializer_list<T>&a={}){fe(a,e)this->eb(e);if constexpr(addable<T>)build_zeta();}
  circle_vec(const vec<T>&v){fe(v,e)this->eb(e);if constexpr(addable<T>)build_zeta();}
  void build_zeta()requires(addable<T>){su=this->zeta();}

  T&operator[](ll i){ll n=this->size();return vec<T>::operator[]((i%n+n)%n);}
  T operator[](ll i)const{ll n=this->size();return vec<T>::operator[]((i%n+n)%n);}
  T circle_sum(ll n)const requires(addable<T>){auto[q,r]=divmod(n,this->size());return su.back()*q+schrodinger(r,su[r-1]);}
};

multiple_testcases
void solve(){
  LL(a,N);
  ll M=sqrt_floor(a*N);

  auto f=[&](ll i){return mod(square(i+1)-1,a);};
  circle_vec<ml>v=iota_lambda(a,f).cast_core_type<ml>();
  pp(ml(N)*M-(square_sum<ml>(M)-M-v.circle_sum(M))/a);
}}