There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on.

Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second — at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.

Determine the sum of dissatisfaction of all participants.

Input

The first line contains a single integer k (1 ≤ k ≤ 1000) — the number of test cases.

Each of the next k lines contains three integers n, x, t (1 ≤ n, x, t ≤ 2 ⋅ 10^9) — the number of participants, the start interval and the contest duration.

Output

Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.

Example

Input


4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000


Output


5
3
3
1999999999000000000

Note

In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2. 

The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2. 

The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.

The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.

In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2. 

The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
        import java.io.*;
        import java.math.BigDecimal;
        import java.math.BigInteger;
        import java.math.RoundingMode;
        import java.text.CollationElementIterator;
        import java.util.*;
        //changed
        import javax.lang.model.type.IntersectionType;
        import javax.print.attribute.standard.PrinterResolution;
        import javax.swing.text.html.CSS;
        public class codeforces {
            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;
                }
            }

            static int m = 1000000007;

            static long[][] multiply(long a[][], long b[][]) {
                long res[][] = new long[2][2];
                res[0][0] = ((a[0][0] * b[0][0]) % m + (a[0][1] * b[1][0]) % m) % m;
                res[0][1] = ((a[0][0] * b[0][1]) % m + (a[0][1] * b[1][1]) % m) % m;
                res[1][0] = ((a[1][0] * b[0][0]) % m + (a[1][1] * b[1][0]) % m) % m;
                res[1][1] = ((a[1][0] * b[0][1]) % m + (a[1][1] * b[1][1]) % m) % m;
                return res;
            }

            static boolean isKthBitSet(int n,
                                       int k) {
                if (((n >> (k)) &
                        1) > 0)
                    return true;
                return false;
            }

            static void move(char a[], int i) {
                int j = 0;
                int temp1 = i;
                while (j < i) {
                    char temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    j++;
                    i--;
                }
                for (int k = 0; k <= temp1; k++) {
                    a[k] = (a[k] == '0') ? '1' : '0';
                }
            }

            static int fact(int a) {
                int f = 1;
                for (int i = 2; i <= a; i++)
                    f *= i;
                return f;
            }

            static long gcd(long a, long b) {
                if (a == 0)
                    return b;
                return gcd(b % a, a);

            }

            static class pair {
                int  first;
                int second;

                pair(int first, int second) {
                    this.first = first;
                    this.second = second;
                }
            }
            static long gcdx(long x,long y)
            {
                if(y==0)
                    return x;
                return gcd(y,x%y);
            }
            public static void main(String[] args) throws IOException {
                PrintWriter out = new PrintWriter(System.out);
                InputReader sc = new InputReader(System.in);
                    int t1=sc.nextInt();
                    while(t1-->0) {
                        int n = sc.nextInt();
                        long x = sc.nextLong();
                        long t = sc.nextLong();
                        long z=Math.min(n-1,t/x);
                        if(z==0)
                        {
                            System.out.println(0);
                            continue;
                        }
                        long d=Math.max(0L,z*(z-1)/2+z*(n-z));
                        System.out.println(d);
                    }
                }


            static class InputReader {
                private InputStream in;
                private byte[] buffer = new byte[1024];
                private int curbuf;
                private int lenbuf;
                public InputReader(InputStream in) {
                    this.in = in;
                    this.curbuf = this.lenbuf = 0;
                }
                public boolean hasNextByte() {
                    if (curbuf >= lenbuf) {
                        curbuf = 0;
                        try {
                            lenbuf = in.read(buffer);
                        } catch (IOException e) {
                            throw new InputMismatchException();
                        }
                        if (lenbuf <= 0)
                            return false;
                    }
                    return true;
                }

                private int readByte() {
                    if (hasNextByte())
                        return buffer[curbuf++];
                    else
                        return -1;
                }

                private boolean isSpaceChar(int c) {
                    return !(c >= 33 && c <= 126);
                }

                private void skip() {
                    while (hasNextByte() && isSpaceChar(buffer[curbuf]))
                        curbuf++;
                }

                public boolean hasNext() {
                    skip();
                    return hasNextByte();
                }

                public String next() {
                    if (!hasNext())
                        throw new NoSuchElementException();
                    StringBuilder sb = new StringBuilder();
                    int b = readByte();
                    while (!isSpaceChar(b)) {
                        sb.appendCodePoint(b);
                        b = readByte();
                    }
                    return sb.toString();
                }

                public int nextInt() {
                    if (!hasNext())
                        throw new NoSuchElementException();
                    int c = readByte();
                    while (isSpaceChar(c))
                        c = readByte();
                    boolean minus = false;
                    if (c == '-') {
                        minus = true;
                        c = readByte();
                    }
                    int res = 0;
                    do {
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res = res * 10 + c - '0';
                        c = readByte();
                    } while (!isSpaceChar(c));
                    return (minus) ? -res : res;
                }

                public long nextLong() {
                    if (!hasNext())
                        throw new NoSuchElementException();
                    int c = readByte();
                    while (isSpaceChar(c))
                        c = readByte();
                    boolean minus = false;
                    if (c == '-') {
                        minus = true;
                        c = readByte();
                    }
                    long res = 0;
                    do {
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res = res * 10 + c - '0';
                        c = readByte();
                    } while (!isSpaceChar(c));
                    return (minus) ? -res : res;
                }

                public double nextDouble() {
                    return Double.parseDouble(next());
                }

                public int[] nextIntArray(int n) {
                    int[] a = new int[n];
                    for (int i = 0; i < n; i++)
                        a[i] = nextInt();
                    return a;
                }

                public long[] nextLongArray(int n) {
                    long[] a = new long[n];
                    for (int i = 0; i < n; i++)
                        a[i] = nextLong();
                    return a;
                }

                public char[][] nextCharMap(int n, int m) {
                    char[][] map = new char[n][m];
                    for (int i = 0; i < n; i++)
                        map[i] = next().toCharArray();
                    return map;
                }
            }
        }
        class MergeSort {
            // Merges two subarrays of arr[].
            // First subarray is arr[l..m]
            // Second subarray is arr[m+1..r]
            static void  merge(long arr[], int l, int m, int r) {
                // Find sizes of two subarrays to be merged
                int n1 = m - l + 1;
                int n2 = r - m;

                /* Create temp arrays */
                long L[] = new long[n1];
                long R[] = new long[n2];

                /*Copy data to temp arrays*/
                for (int i = 0; i < n1; ++i)
                    L[i] = arr[l + i];
                for (int j = 0; j < n2; ++j)
                    R[j] = arr[m + 1 + j];


                /* Merge the temp arrays */

                // Initial indexes of first and second subarrays
                int i = 0, j = 0;

                // Initial index of merged subarry array
                int k = l;
                while (i < n1 && j < n2) {
                    if (L[i] <= R[j]) {
                        arr[k] = L[i];
                        i++;
                    } else {
                        arr[k] = R[j];
                        j++;
                    }
                    k++;
                }

                /* Copy remaining elements of L[] if any */
                while (i < n1) {
                    arr[k] = L[i];
                    i++;
                    k++;
                }

                /* Copy remaining elements of R[] if any */
                while (j < n2) {
                    arr[k] = R[j];
                    j++;
                    k++;
                }
            }

            // Main function that sorts arr[l..r] using
            // merge()
            static void sort(long arr[], int l, int r) {
                if (l < r) {
                    // Find the middle point
                    int m = (l + r) / 2;

                    // Sort first and second halves
                    sort(arr, l, m);
                    sort(arr, m + 1, r);

                    // Merge the sorted halves
                    merge(arr, l, m, r);
                }
            }
        }
        class SegTree<S> {
            final int MAX;

            final int N;
            final java.util.function.BinaryOperator<S> op;
            final S E;

            final S[] data;

            @SuppressWarnings("unchecked")
            public SegTree(int n, java.util.function.BinaryOperator<S> op, S e) {
                this.MAX = n;
                int k = 1;
                while (k < n) k <<= 1;
                this.N = k;
                this.E = e;
                this.op = op;
                this.data = (S[]) new Object[N << 1];
                java.util.Arrays.fill(data, E);
            }

            public SegTree(S[] dat, java.util.function.BinaryOperator<S> op, S e) {
                this(dat.length, op, e);
                build(dat);
            }

            private void build(S[] dat) {
                int l = dat.length;
                System.arraycopy(dat, 0, data, N, l);
                for (int i = N - 1; i > 0; i--) {
                    data[i] = op.apply(data[i << 1 | 0], data[i << 1 | 1]);
                }
            }

            public void set(int p, S x) {
                exclusiveRangeCheck(p);
                data[p += N] = x;
                p >>= 1;
                while (p > 0) {
                    data[p] = op.apply(data[p << 1 | 0], data[p << 1 | 1]);
                    p >>= 1;
                }
            }

            public S get(int p) {
                exclusiveRangeCheck(p);
                return data[p + N];
            }

            public S prod(int l, int r) {
                if (l > r) {
                    throw new IllegalArgumentException(
                            String.format("Invalid range: [%d, %d)", l, r)
                    );
                }
                inclusiveRangeCheck(l);
                inclusiveRangeCheck(r);
                S sumLeft = E;
                S sumRight = E;
                l += N; r += N;
                while (l < r) {
                    if ((l & 1) == 1) sumLeft = op.apply(sumLeft, data[l++]);
                    if ((r & 1) == 1) sumRight = op.apply(data[--r], sumRight);
                    l >>= 1; r >>= 1;
                }
                return op.apply(sumLeft, sumRight);
            }

            public S allProd() {
                return data[1];
            }

            public int maxRight(int l, java.util.function.Predicate<S> f) {
                inclusiveRangeCheck(l);
                if (!f.test(E)) {
                    throw new IllegalArgumentException("Identity element must satisfy the condition.");
                }
                if (l == MAX) return MAX;
                l += N;
                S sum = E;
                do {
                    l >>= Integer.numberOfTrailingZeros(l);
                    if (!f.test(op.apply(sum, data[l]))) {
                        while (l < N) {
                            l = l << 1;
                            if (f.test(op.apply(sum, data[l]))) {
                                sum = op.apply(sum, data[l]);
                                l++;
                            }
                        }
                        return l - N;
                    }
                    sum = op.apply(sum, data[l]);
                    l++;
                } while ((l & -l) != l);
                return MAX;
            }

            public int minLeft(int r, java.util.function.Predicate<S> f) {
                inclusiveRangeCheck(r);
                if (!f.test(E)) {
                    throw new IllegalArgumentException("Identity element must satisfy the condition.");
                }
                if (r == 0) return 0;
                r += N;
                S sum = E;
                do {
                    r--;
                    while (r > 1 && (r & 1) == 1) r >>= 1;
                    if (!f.test(op.apply(data[r], sum))) {
                        while (r < N) {
                            r = r << 1 | 1;
                            if (f.test(op.apply(data[r], sum))) {
                                sum = op.apply(data[r], sum);
                                r--;
                            }
                        }
                        return r + 1 - N;
                    }
                    sum = op.apply(data[r], sum);
                } while ((r & -r) != r);
                return 0;
            }

            private void exclusiveRangeCheck(int p) {
                if (p < 0 || p >= MAX) {
                    throw new IndexOutOfBoundsException(
                            String.format("Index %d out of bounds for the range [%d, %d).", p, 0, MAX)
                    );
                }
            }

            private void inclusiveRangeCheck(int p) {
                if (p < 0 || p > MAX) {
                    throw new IndexOutOfBoundsException(
                            String.format("Index %d out of bounds for the range [%d, %d].", p, 0, MAX)
                    );
                }

            }
        }
        class MathLib{
            public static int[] sieveEratostheness(int n) {
                if (n <= 32) {
                    int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
                    for (int i = 0; i < primes.length; i++) {
                        if (n < primes[i]) {
                            return Arrays.copyOf(primes, i);
                        }
                    }
                    return primes;
                }

                int u = n + 32;
                double lu = Math.log(u);
                int[] ret = new int[(int) (u / lu + u / lu / lu * 1.5)];
                ret[0] = 2;
                int pos = 1;

                int[] isnp = new int[(n + 1) / 32 / 2 + 1];
                int sup = (n + 1) / 32 / 2 + 1;

                int[] tprimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
                for (int tp : tprimes) {
                    ret[pos++] = tp;
                    int[] ptn = new int[tp];
                    for (int i = (tp - 3) / 2; i < tp << 5; i += tp) ptn[i >> 5] |= 1 << (i & 31);
                    for (int j = 0; j < sup; j += tp) {
                        for (int i = 0; i < tp && i + j < sup; i++) {
                            isnp[j + i] |= ptn[i];
                        }
                    }
                }

                // 3,5,7
                // 2x+3=n
                int[] magic = {0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13, 31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14};
                int h = n / 2;
                for (int i = 0; i < sup; i++) {
                    for (int j = ~isnp[i]; j != 0; j &= j - 1) {
                        int pp = i << 5 | magic[(j & -j) * 0x076be629 >>> 27];
                        int p = 2 * pp + 3;
                        if (p > n) break;
                        ret[pos++] = p;
                        if ((long) p * p > n) continue;
                        for (int q = (p * p - 3) / 2; q <= h; q += p) isnp[q >> 5] |= 1 << q;
                    }
                }

                return Arrays.copyOf(ret, pos);
            }
            static boolean[] sieveOfEratosthenes(int n) {
                // Create a boolean array
                // "prime[0..n]" and
                // initialize all entries
                // it as true. A value in
                // prime[i] will finally be
                // false if i is Not a
                // prime, else true.
                boolean prime[] = new boolean[n + 1];
                for (int i = 0; i <= n; i++)
                    prime[i] = true;

                for (int p = 2; p * p <= n; p++) {
                    // If prime[p] is not changed, then it is a
                    // prime
                    if (prime[p] == true) {
                        // Update all multiples of p
                        for (int i = p * p; i <= n; i += p)
                            prime[i] = false;
                    }
                }
                return prime;
            }
            public static int getMax(int[] inputArray){
                int maxValue = inputArray[0];
                for(int i=1;i < inputArray.length;i++){
                    if(inputArray[i] > maxValue){
                        maxValue = inputArray[i];
                    }
                }
                return maxValue;
            }

            // Method for getting the minimum value
            public static int getMin(int[] inputArray){
                int minValue = inputArray[0];
                for(int i=1;i<inputArray.length;i++){
                    if(inputArray[i] < minValue){
                        minValue = inputArray[i];
                    }
                }
                return minValue;
            }
            static int countSetBits(long n)
            {
                int count = 0;
                while (n > 0) {
                    count += n & 1;
                    n >>= 1;
                }
                return count;
            }
            static long binpow(long a, long b) {
                long res = 1;
                while (b > 0) {
                    if ((b & 1)>0)
                        res = res * a;
                    a = a * a;
                    b >>= 1;
                }
                return res;
            }
            static ArrayList<Integer> printDivisors(int n)
            {
                ArrayList<Integer> al=new ArrayList<>();
                for (int i=2; i<=Math.sqrt(n); i++)
                {
                    if (n%i==0)
                    {
                        // If divisors are equal, print only one
                        if (n/i == i)
                            al.add(i);

                        else // Otherwise print both
                        {
                            al.add(i);
                            al.add(n/i);
                        }

                    }
                }
                return al;
            }

            static long fastPow(long a, long b, long mod) {
                if(b == 0)
                    return 1L;

                long val = fastPow(a, b/2, mod);
                if(b % 2 == 0)
                    return val * val % mod;
                else
                    return val * val % mod * a % mod;
            }
            static int LowerBound(int a[], int x) { // x is the target value or key
                int l=-1,r=a.length;
                while(l+1<r) {
                    int m=(l+r)>>>1;
                    if(a[m]>=x) r=m;
                    else l=m;
                }
                return r;
            }
            static int UpperBound(int a[], int x) {// x is the key or target value
                int l=-1,r=a.length;
                while(l+1<r) {
                    int m=(l+r)>>>1;
                    if(a[m]<=x) l=m;
                    else r=m;
                }
                return l+1;
            }
            private static long safe_mod(long x, long m){
                x %= m;
                if(x<0) x += m;
                return x;
            }

            private static long[] inv_gcd(long a, long b){
                a = safe_mod(a, b);
                if(a==0) return new long[]{b,0};

                long s=b, t=a;
                long m0=0, m1=1;
                while(t>0){
                    long u = s/t;
                    s -= t*u;
                    m0 -= m1*u;
                    long tmp = s; s = t; t = tmp;
                    tmp = m0; m0 = m1; m1 = tmp;
                }
                if(m0<0) m0 += b/s;
                return new long[]{s,m0};
            }

            public static long gcd(long a, long b){
                a = java.lang.Math.abs(a);
                b = java.lang.Math.abs(b);
                return inv_gcd(a, b)[0];
            }
            public static long lcm(long a, long b){
                a = java.lang.Math.abs(a);
                b = java.lang.Math.abs(b);
                return a / gcd(a,b) * b;
            }

            public static long pow_mod(long x, long n, int m){
                assert n >= 0;
                assert m >= 1;
                if(m == 1)return 0L;
                x = safe_mod(x, m);
                long ans = 1L;
                while(n > 0){
                    if((n&1) == 1) ans = (ans * x) % m;
                    x = (x*x) % m;
                    n >>>= 1;
                }
                return ans;
            }
            static long fact[]=new long[1000001];
            static long inv_fact[]=new long[1000001];
            static int p=1000000007;
            public static void precomp()
            {
                fact[0]=fact[1]=1;
                for(int i=2;i<=fact.length-1;i++)
                {
                    fact[i]=(fact[i-1]*i)%p;
                }
                inv_fact[(int)1e6]=modpow(fact[(int)1e6],p-2);
                for(int i=fact.length-2;i>=0;i--)
                {
                    inv_fact[i]=(inv_fact[i+1]*(i+1))%p;
                }
            }
            public static boolean summ(int n,int a,int b)
            {
                while(n>0)
                {
                    if(n%10!=a && n%10!=b)return false;
                    n/=10;
                }
                return true;
            }
            public static long modpow(long x,long n)
            {
                long res=1;
                while(n>0)
                {
                    if(n%2!=0)
                    {
                        res=(res*x)%p;n--;
                    }
                    else
                    {
                        x=(x*x)%p;n/=2;
                    }
                }
                return res;
            }
            public static long ncr(int n,int r)
            {
                if(r>n || r<0 || n<0)return 0;
                return fact[n]*inv_fact[r]%p*inv_fact[n-r]%p;
            }

            public static long[] crt(long[] r, long[] m){
                assert(r.length == m.length);
                int n = r.length;

                long r0=0, m0=1;
                for(int i=0; i<n; i++){
                    assert(1 <= m[i]);
                    long r1 = safe_mod(r[i], m[i]), m1 = m[i];
                    if(m0 < m1){
                        long tmp = r0; r0 = r1; r1 = tmp;
                        tmp = m0; m0 = m1; m1 = tmp;
                    }
                    if(m0%m1 == 0){
                        if(r0%m1 != r1) return new long[]{0,0};
                        continue;
                    }

                    long[] ig = inv_gcd(m0, m1);
                    long g = ig[0], im = ig[1];

                    long u1 = m1/g;
                    if((r1-r0)%g != 0) return new long[]{0,0};

                    long x = (r1-r0) / g % u1 * im % u1;

                    r0 += x * m0;
                    m0 *= u1;
                    if(r0<0) r0 += m0;
                    //System.err.printf("%d %d\n", r0, m0);
                }
                return new long[]{r0, m0};
            }
            public static long floor_sum(long n, long m, long a, long b){
                long ans = 0;
                if(a >= m){
                    ans += (n-1) * n * (a/m) / 2;
                    a %= m;
                }
                if(b >= m){
                    ans += n * (b/m);
                    b %= m;
                }

                long y_max = (a*n+b) / m;
                long x_max = y_max * m - b;
                if(y_max == 0) return ans;
                ans += (n - (x_max+a-1)/a) * y_max;
                ans += floor_sum(y_max, a, m, (a-x_max%a)%a);
                return ans;
            }

            public static java.util.ArrayList<Long> divisors(long n){
                java.util.ArrayList<Long> divisors = new ArrayList<>();
                java.util.ArrayList<Long> large = new ArrayList<>();

                for(long i=1; i*i<=n; i++) if(n%i==0){
                    divisors.add(i);
                    if(i*i<n) large.add(n/i);
                }
                for(int p=large.size()-1; p>=0; p--){
                    divisors.add(large.get(p));
                }
                return divisors;
            }
        }