description: Theofanis really likes sequences of positive integers, thus his teacher (Yeltsa Kcir) gave him a problem about a sequence that consists of only special numbers.
  
  Let's call a positive number special if it can be written as a sum of different non-negative powers of n. For example, for n = 4 number 17 is special, because it can be written as 4^0 + 4^2 = 1 + 16 = 17, but 9 is not.
  
  Theofanis asks you to help him find the k-th special number if they are sorted in increasing order. Since this number may be too large, output it modulo 10^9+7.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
  
  The first and only line of each test case contains two integers n and k (2 ≤ n ≤ 10^9; 1 ≤ k ≤ 10^9).
  
  Output
  
  For each test case, print one integer — the k-th special number in increasing order modulo 10^9+7.
  
  Example
  
  Input
  
  
  3
  3 4
  2 12
  105 564
  
  
  Output
  
  
  9
  12
  3595374
  
  Note
  
  For n = 3 the sequence is [1,3,4,9...]
solution: import java.io.*;
  import java.util.*;
  import java.lang.*;
  
  public class Main{
      public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
      static long MOD = (long) (1e9 + 7);
  //    static long MOD = 998244353;
      static long MOD2 = MOD * MOD;
      static FastReader sc = new FastReader();
      static int pInf = Integer.MAX_VALUE;
      static int nInf = Integer.MIN_VALUE;
      static long ded = (long)(1e17)+9;
      public static void main(String[] args) throws Exception {
          int test = 1;
          test = sc.nextInt();
          for (int i = 1; i <= test; i++){
  //            out.print("Case #"+i+": ");
              solve();
          }
          out.flush();
          out.close();
      }
      static void solve(){
          long n = sc.nextLong();
          int k = sc.nextInt();
          long ans = 0L;
          for(int i = 0; i < 32; i++){
              if((k&(1<<i))>0){
                  ans = add(ans,modpow(n,i));
              }
          }
          out.println(ans);
      }
      public static long mul(long a, long b) {
          return ((a % MOD) * (b % MOD)) % MOD;
      }
      public static long sub(long a, long b) {
          return ((a%MOD)-(b%MOD)+MOD)%MOD;
      }
      public static long add(long a, long b) {
          if((a+b)>MOD){
              return a+b-MOD;
          }else{
              return a+b;
          }
  //        return ((a % MOD) + (b % MOD)) % MOD;
      }
      static class Pair implements Comparable<Pair> {
          long x;
          long y;
          public Pair(long x, long y) {
              this.x = x;
              this.y = y;
          }
          @Override
          public int compareTo(Pair o){
              if(this.x==o.x){
                  return -1*Long.compare(this.y,o.y);
              }
              return Long.compare(this.x,o.x);
          }
  
          @Override
          public String toString() {
              return "Pair{" + "x=" + x + ", y=" + y + '}';
  //            return x+" "+y;
          }
  
  //        public boolean equals(Pair o){
  //            return this.x==o.x&&this.y==o.y;
  //        }
      }
      public static long c2(long n) {
          if ((n & 1) == 0) {
              return mul(n / 2, n - 1);
          } else {
              return mul(n, (n - 1) / 2);
          }
      }
      //Shuffle Sort
      static final Random random = new Random();
      static void ruffleSort(int[] a) {
          int n = a.length;//shuffle, then sort
          for (int i = 0; i < n; i++) {
              int oi = random.nextInt(n); int temp= a[oi];
              a[oi] = a[i];
              a[i] = temp;
          }
          Arrays.sort(a);
      }
      //Brian Kernighans Algorithm
      static long countSetBits(long n) {
          if (n == 0) return 0;
          return 1 + countSetBits(n & (n - 1));
      }
      //Euclidean Algorithm
      static long gcd(long A, long B) {
          if (B == 0) return A;
          return gcd(B, A % B);
      }
      //Modular Exponentiation
      static long fastExpo(long x, long n) {
          if (n == 0) return 1;
          if ((n & 1) == 0) return fastExpo((x * x) % MOD, n / 2) % MOD;
          return ((x % MOD) * fastExpo((x * x) % MOD, (n - 1) / 2)) % MOD;
      }
      //AKS Algorithm
      static boolean isPrime(long n) {
          if (n <= 1) return false;
          if (n <= 3) return true;
          if (n % 2 == 0 || n % 3 == 0) return false;
          for (int i = 5; i <= Math.sqrt(n); i += 6)
              if (n % i == 0 || n % (i + 2) == 0) return false;
          return true;
      }
      public static long modinv(long x) {
          return modpow(x, MOD - 2);
      }
      public static long modpow(long a, long b) {
          if (b == 0) {
              return 1;
          }
          long x = modpow(a, b / 2);
          x = (x * x) % MOD;
          if (b % 2 == 1) {
              return (x * a) % MOD;
          }
          return x;
      }
  
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
          public FastReader() {
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  }