You are given a board of size n × n, where n is odd (not divisible by 2). Initially, each cell of the board contains one figure.

In one move, you can select exactly one figure presented in some cell and move it to one of the cells sharing a side or a corner with the current cell, i.e. from the cell (i, j) you can move the figure to cells: 

  * (i - 1, j - 1); 
  * (i - 1, j); 
  * (i - 1, j + 1); 
  * (i, j - 1); 
  * (i, j + 1); 
  * (i + 1, j - 1); 
  * (i + 1, j); 
  * (i + 1, j + 1); 



Of course, you can not move figures to cells out of the board. It is allowed that after a move there will be several figures in one cell.

Your task is to find the minimum number of moves needed to get all the figures into one cell (i.e. n^2-1 cells should contain 0 figures and one cell should contain n^2 figures).

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 200) — the number of test cases. Then t test cases follow.

The only line of the test case contains one integer n (1 ≤ n < 5 ⋅ 10^5) — the size of the board. It is guaranteed that n is odd (not divisible by 2).

It is guaranteed that the sum of n over all test cases does not exceed 5 ⋅ 10^5 (∑ n ≤ 5 ⋅ 10^5).

Output

For each test case print the answer — the minimum number of moves needed to get all the figures into one cell.

Example

Input


3
1
5
499993


Output


0
40
41664916690999888
#include <bits/stdc++.h>
#include <chrono>
#include <random>
#define sz(v) (int)(v.size())
#define ll long long int
#define ull unsigned long long int
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define do(i,n) for(ll i=0;i<n;i++)
#define loop(i,a,b) for(ll i=a;i<=b;i++)
#define vi vector <int>
#define vs vector <string>
#define vc vector <char>
#define vl vector <ll>
#define all(c) (c).begin(),(c).end()
#define max3(a,b,c) max(max(a,b),c)
#define min3(a,b,c) min(min(a,b),c)
#define deb(x) cerr<<#x<<' '<<'='<<' '<<x<<'\n'
using namespace std;
#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp> 
using namespace __gnu_pbds; 
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
// ordered_set s ; s.order_of_key(val)  no. of elements strictly less than val
// s.find_by_order(i)  itertor to ith element (0 indexed)
typedef vector<vector<ll>> matrix;
ll power(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
ll modInverse(ll a){return power(a,mod-2);}
const int N=500023;
bool vis[N];
vector <int> adj[N];

// void solve(){
    
//     ll n,h,m;
//     cin>>n>>h>>m;
//     ll dp[n][n];
//     memset(dp,h,sizeof dp);
    
//     ll ans=0;
//     do(i,m){
        
//         ll l,r,x;
        
//         cin>>l>>r>>x;
//         if(x==h) continue;
//         for(int i=l+1;i<r-1;i++){
            
//                 dp[i][i]=x*x;
//         }
    
        
//         dp[l][l]=min(dp[l][l],x*x);
//         dp[r][r]=min(dp[r][r],x*x);
        

        
//     }
    
    
//      for(int i=0;i<n;i++){
//       ans+=dp[i][i];
     
//     }
//     cout<<ans<<endl;
        
    
      
//   } 

    




//   int n;
//   cin>>n;
//   vi v(n);
//   ll dp[n][n];
//   for(int i=0;i<n;i++){
      
//       cin>>v[i];
//       dp[i][i]=v[i];
//   }
  
//     for(int i=n;i>=0;i++){
        
        
//         for(int j=i+1;j<n;j++){
            
            
//             dp[i][j]=((i+1>j-1)?0:dp[i+1][j-1])+v[i]+v[j];
            
//         }}
     
//      int t=0;   
//     for(int i=0;i<n;i++){
        
        
//         for(int j=i;j<n;j++){
            
            
//           if(dp[i][j]==v[i])t++;
            
//         }}
 
//     cout<<t<<endl;
  
// }

// ll f(ll n){
//     ll k=2;
//     ll ans;
    
//     while(k <= n){
        
        
//         if(n%k==0)
//             {
                
                
//                 ans=k;
//                 break;
                
//             }
//         else k++;
        
        
        
        
//     }
//     // cout<<"aa"<<ans;
//     return ans;
    
    
// }

void solve(){
 
 
ll n;
cin>>n;
if(n==1){cout<<0<<endl;return;}
ll m=(n-1)/2;


cout<<4*(m*(m+1)/2 + 1 + m*(m*m-1))<<endl;



    
}

    
// void solve(){
    
//         ll  n,k;
//         cin>>n>>k;
        
//         vi v(n+1);
//         vi dp(n);
        
//         do(i,n)cin>>v[i+1];
        
        
//         ll p=INT_MIN,lmin=INT_MAX;
       
//         dp[0]=0;
        
//         for(ll l=1;l<=n-k+1;l++){
            
//             ll r=l+k-1;
            
//             if(l==1){
                
//                 for(int t=l;t<=r;t++){
                    
                    
//                       dp[l] +=(   ((t==l)||(t==r)?false:  (v[t]>v[t+1] && v[t]>v[t-1])      )?1:0);
                      
                    
//                 }
//                 // cout<<"intit"<<dp[l];
                
//             }
            
            
//             else{
                
//             dp[l]= dp[l-1] + (  (v[l]>v[l+1] && v[l]>v[l-1])?-1:0) +
//                                 ((v[r-1]>v[r] && v[r-1]>v[r-2]) ?1:0);
            
//             }
            
//             // cout<<"dp"<<l<<"  "<<dp[l]<<endl;
            
//             if(p<dp[l]){
//                 p=dp[l];
//                 lmin=l;
//             }
            
                
//             if(p==dp[l])
//                 lmin=min(lmin,l);    
            
                
            
//             }     

        
        
//         cout<<p+1<<" "<<lmin<<endl;
    
   
// }

// int _lis( int arr[], int n, int *max_ref) 
// { 
//     /* Base case */
//     if (n == 1) 
//         return 1; 
  
//     // 'max_ending_here' is length of LIS ending with arr[n-1] 
//     int res, max_ending_here = 1;  
  
//     /* Recursively get all LIS ending with arr[0], arr[1] ... 
//       arr[n-2]. If   arr[i-1] is smaller than arr[n-1], and 
//       max ending with arr[n-1] needs to be updated, then 
//       update it */
//     for (int i = 1; i < n; i++) 
//     { 
//         res = _lis(arr, i, max_ref); 
//         if (arr[i-1] < arr[n-1] && res + 1 > max_ending_here) 
//             max_ending_here = res + 1; 
//     } 
  
//     // Compare max_ending_here with the overall max. And 
//     // update the overall max if needed 
//     if (*max_ref < max_ending_here) 
//       *max_ref = max_ending_here; 
  
//     // Return length of LIS ending with arr[n-1] 
//     return max_ending_here; 
// } 
  
// // The wrapper function for _lis() 
// int lis(int arr[], int n) 
// { 
//     // The max variable holds the result 
//     int max = 1; 
  
//     // The function _lis() stores its result in max 
//     _lis( arr, n, &max ); 
  
//     // returns max 
//     return max; 
// } 

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int T=1;
    cin>>T;
    while(T--)
    {
        //cout<<"Case #"<<t<<":"<<' ';
        solve();
        //cout<<'\n';
    }
    cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
}