Problem: A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.

Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.

The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example: 

  * for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4]; 
  * for permutation [1, 2, 3] the next permutation is [1, 3, 2]; 
  * for permutation [2, 1] next permutation does not exist. 



You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).

You need to process q queries of two types: 

  * 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r]. 
  * 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2]. 



For each query of the 1-st type output the required sum.

Input

The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.

The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).

It is guaranteed that all requests of the 2-nd type are possible to process.

Output

For each query of the 1-st type, output on a separate line one integer — the required sum.

Example

Input


4 4
1 2 4
2 3
1 1 2
1 3 4


Output


9
4
6

Note

Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows: 

  1. 2 + 3 + 4 = 9; 
  2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2]; 
  3. 1 + 3 = 4; 
  4. 4 + 2 = 6 

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
 
public class Solution extends PrintWriter {
    
    int K = 14;
    long[] fac = new long[K+1];
    
    void build_fac(){
        fac[0] = 1L;
        for (int i = 1; i <= K; i++) fac[i] = fac[i - 1] * i;
    }

    private void solve() {
        build_fac();
        
        int n = sc.nextInt();
        map = new int[K];
        for(int i = K-1, j = 0; i >= 0 && n-j >= 0; i--, j++) {
            map[i] = n-j;
        }
        long perm = 0L;
        int[] p = integerToPermutation(perm);
        int q = sc.nextInt();
        for(int i = 0; i < q; i++) {
            int qt = sc.nextInt();
            if(qt == 1) {
                int l = sc.nextInt();
                int r = sc.nextInt();
                long ans = 0L;
                if(n >= K) {
                    long ll = Math.min(l, n-K+1);
                    long rr = Math.min(r, n-K);
                    ans += ((ll+rr)*(rr-ll+1))/2L;
                }
                int dl = n-l;
                int dr = n-r;
                for(int k = Math.max(0,K-1-dl); k <= Math.max(-1,K-1-dr); k++) {
                    ans += p[k];
                }
                println(ans);
            } else {
                int x = sc.nextInt();
                perm += x;
                p = integerToPermutation(perm);
            }
        }
    }    
    
    int[] map;
    
    void build(int il, int ir, int i) {
        if (il == ir) {
            sum[i] = 1;
        }
        else {
            int imid = (il + ir) / 2;
            build(il, imid, 2 * i);
            build(imid + 1, ir, 2 * i + 1);
            sum[i] = sum[2 * i] + sum[2 * i + 1];
        }
    }
    
    int[] integerToPermutation(long perm) {
        build(0, K - 1, 1);
        int[] p = new int[K];
        for (int i = 0; i < K; i++) p[i] = 0;
        for (int i = 0; i < K; i++) {
            long idx = perm / fac[K - 1 - i] + 1L;
            p[i] = query(0, K - 1, 1, idx);
            add(0, K - 1, 1, p[i], -1);
            perm = perm % fac[K - 1 - i];
        }
        for(int i = 0; i < K; i++) p[i] = map[p[i]];
        return p;
    }
    
    int[] sum = new int[4*K];
    
    int query(int il, int ir, int i, long val) {
        if (il == ir) {
            if (val <= sum[i]) return il;
            else return -1;
        }
        else {
            int imid = (il + ir) / 2;
            if (val <= sum[2 * i]) return query(il, imid, 2 * i, val);
            else return query(imid + 1, ir, 2 * i + 1, val - sum[2 * i]);
        }
    }
    
    void add(int il, int ir, int i, int q, int val) {
        if (q < il || q > ir) return;
     
        if (q <= il && ir <= q) {
            sum[i] += val;
            return;
        }
     
        int imid = (il + ir) / 2;
        add(il, imid, 2 * i, q, val);
        add(imid + 1, ir, 2 * i + 1, q, val);
        sum[i] = sum[2 * i] + sum[2 * i + 1];
    }
    
//  Solution() throws FileNotFoundException { super(new File("output.txt")); }
//  InputReader sc = new InputReader(new FileInputStream("test_input.txt"));
  Solution() { super(System.out); }
  InputReader sc = new InputReader(System.in);
  static class InputReader {
      InputReader(InputStream in) { this.in = in; } InputStream in;
      
      private byte[] buf = new byte[16384];
      private int    curChar;
      private int    numChars;
      
 
      public int read() {
          if (numChars == -1)
              throw new InputMismatchException();
          if (curChar >= numChars) {
              curChar = 0;
              try {
                  numChars = in.read(buf);
              } catch (IOException e) {
                  throw new InputMismatchException();
              }
              if (numChars <= 0)
                  return -1;
          }
          return buf[curChar++];
      }
 
      public String nextLine() {
          int c = read();
          while (isSpaceChar(c))
              c = read();
          StringBuilder res = new StringBuilder();
          do {
              res.appendCodePoint(c);
              c = read();
          } while (!isEndOfLine(c));
          return res.toString();
      }
 
      public String nextString() {
          int c = read();
          while (isSpaceChar(c))
              c = read();
          StringBuilder res = new StringBuilder();
          do {
              res.appendCodePoint(c);
              c = read();
          } while (!isSpaceChar(c));
          return res.toString();
      }
 
      public long nextLong() {
          int c = read();
          while (isSpaceChar(c))
              c = read();
          int sgn = 1;
          if (c == '-') {
              sgn = -1;
              c = read();
          }
          long res = 0;
          do {
              if (c < '0' || c > '9')
                  throw new InputMismatchException();
              res *= 10;
              res += c - '0';
              c = read();
          } while (!isSpaceChar(c));
          return res * sgn;
      }
 
      public int nextInt() {
          int c = read();
          while (isSpaceChar(c))
              c = read();
          int sgn = 1;
          if (c == '-') {
              sgn = -1;
              c = read();
          }
          int res = 0;
          do {
              if (c < '0' || c > '9')
                  throw new InputMismatchException();
              res *= 10;
              res += c - '0';
              c = read();
          } while (!isSpaceChar(c));
          return res * sgn;
      }
 
      private boolean isSpaceChar(int c) {
          return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
      }
 
      private boolean isEndOfLine(int c) {
          return c == '\n' || c == '\r' || c == -1;
      }
  }
 
    public static void main(String[] $) {
        new Thread(null, new Runnable() {
            public void run() {
                long start = System.nanoTime();
                try {Solution solution = new Solution(); solution.solve(); solution.flush();} 
                catch (Exception e) {e.printStackTrace(); System.exit(1);}
                System.err.println((System.nanoTime()-start)/1E9);
            }
        }, "1", 1 << 27).start();
 
    }
    

}