You have a rectangular chocolate bar consisting of n × m single squares. You want to eat exactly k squares, so you may need to break the chocolate bar. 

In one move you can break any single rectangular piece of chocolate in two rectangular pieces. You can break only by lines between squares: horizontally or vertically. The cost of breaking is equal to square of the break length.

For example, if you have a chocolate bar consisting of 2 × 3 unit squares then you can break it horizontally and get two 1 × 3 pieces (the cost of such breaking is 3^2 = 9), or you can break it vertically in two ways and get two pieces: 2 × 1 and 2 × 2 (the cost of such breaking is 2^2 = 4).

For several given values n, m and k find the minimum total cost of breaking. You can eat exactly k squares of chocolate if after all operations of breaking there is a set of rectangular pieces of chocolate with the total size equal to k squares. The remaining n·m - k squares are not necessarily form a single rectangular piece.


-----Input-----

The first line of the input contains a single integer t (1 ≤ t ≤ 40910) — the number of values n, m and k to process.

Each of the next t lines contains three integers n, m and k (1 ≤ n, m ≤ 30, 1 ≤ k ≤ min(n·m, 50)) — the dimensions of the chocolate bar and the number of squares you want to eat respectively.


-----Output-----

For each n, m and k print the minimum total cost needed to break the chocolate bar, in order to make it possible to eat exactly k squares.


-----Examples-----
Input
4
2 2 1
2 2 3
2 2 2
2 2 4

Output
5
5
4
0



-----Note-----

In the first query of the sample one needs to perform two breaks:  to split 2 × 2 bar into two pieces of 2 × 1 (cost is 2^2 = 4),  to split the resulting 2 × 1 into two 1 × 1 pieces (cost is 1^2 = 1). 

In the second query of the sample one wants to eat 3 unit squares. One can use exactly the same strategy as in the first query of the sample.

Starter code:

Solutions:
mem = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]


def f(n, m, k):
    if mem[n][m][k]:
        return mem[n][m][k]
    if (n*m == k) or (k == 0):
        return 0
    cost = 10**9
    for x in range(1, n//2 + 1):
        for z in range(k+1):
            cost = min(cost, m*m + f(n-x, m, k-z) + f(x, m, z))
    for y in range(1, m//2 + 1):
        for z in range(k+1):
            cost = min(cost, n*n + f(n, m-y, k-z) + f(n, y, z))
    mem[n][m][k] = cost
    return cost


t = int(input())
for i in range(t):
    n, m, k = list(map(int, input().split()))
    print(f(n, m, k))



import sys

# sys.stdin = open('ivo.in')

mem = []
for i in range(32):
    mem.append([[-1] * 52 for u in range(32)])

def solve(x, y, z):
    if x > y:
        mem[x][y][z] = solve(y, x, z)
        return mem[x][y][z]
    if x * y == z or z == 0:
        mem[x][y][z] = 0
        return 0
    if x * y < z:
        mem[x][y][z] = -2
        return -2
    res = -2
    for i in range(1, x//2 + 1):
        for eaten in range(z + 1):
            t1 = mem[i][y][eaten] if mem[i][y][eaten] != -1 else solve(i, y, eaten)
            if t1 == -2:
                continue
            t2 = mem[x - i][y][z - eaten] if mem[x - i][y][z - eaten] != -1 else solve(x - i, y, z - eaten)
            if t2 == -2:
                continue
            if res == -2 or res > t1 + t2 + y * y:
                res = t1 + t2 + y * y

    for j in range(1, y//2 + 1):
        for eaten in range(z + 1):
            t1 = mem[x][j][eaten] if mem[x][j][eaten] != -1 else solve(x, j, eaten)
            if t1 == -2:
                continue
            t2 = mem[x][y - j][z - eaten] if mem[x][y - j][z - eaten] != -1 else solve(x, y - j, z - eaten)
            if t2 == -2:
                continue
            if res == -2 or res > t1 + t2 + x * x:
                res = t1 + t2 + x * x

    mem[x][y][z] = res
    return mem[x][y][z]

t = int(sys.stdin.readline())
for it in range(t):
    n, m, k = list(map(int, sys.stdin.readline().split()))
    print(solve(n, m, k))




d = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]


def rec(n, m, k):
    nonlocal d
    if n*m == k or k == 0:
        return 0
    if d[n][m][k] > 0:
        return d[n][m][k]
    if n*m<k:
        return 10**10
    cost = 10**10
    for i in range(1, n // 2 + 1):
        for j in range(k+1):
            cost = min(cost, m*m + rec(n-i, m, k-j) + rec(i, m, j))
    for i in range(1, m // 2 + 1):
        for j in range(k+1):
            cost = min(cost, n*n + rec(n, m-i, k-j) + rec(n, i, j))
    d[n][m][k] = cost
    return cost

p = []
t = int(input())
for i in range(t):
    n, m, k = list(map(int, input().split()))
    p.append(rec(n, m, k))
print('\n'.join(str(x) for x in p))


d = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]


def rec(n, m, k):
    nonlocal d
    if n*m == k or k == 0:
        return 0
    if d[n][m][k] > 0:
        return d[n][m][k]
    if n*m<k:
        return 10**10
    cost = 10**10
    for i in range(1, n // 2 + 1):
        for j in range(k+1):
            cost = min(cost, m*m + rec(n-i, m, k-j) + rec(i, m, j))
    for i in range(1, m // 2 + 1):
        for j in range(k+1):
            cost = min(cost, n*n + rec(n, m-i, k-j) + rec(n, i, j))
    d[n][m][k] = cost
    return cost

p = []
t = int(input())
for i in range(t):
    n, m, k = list(map(int, input().split()))
    #p.append(rec(n, m, k))
    print(rec(n, m, k))
#print('\n'.join(str(x) for x in p))


d = [0] * 49011

def g(n, m, k):
    t = 1e9
    for i in range(1, m // 2 + 1):
        for j in range(k + 1):
            t = min(t, f(n, m - i, k - j) + f(n, i, j))
    return n * n + t

def f(n, m, k):
    if n > m: n, m = m, n
    k = min(k, n * m - k)
    if k == 0: return 0
    if k < 0: return 1e9
    q = n + 31 * m + 961 * k
    if d[q] == 0: d[q] = min(g(n, m, k), g(m, n, k))
    return d[q]

for q in range(int(input())):
    n, m, k = map(int, input().split())
    print(f(n, m, k))

d = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]


def rec(n, m, k):
    nonlocal d
    if n*m == k or k == 0:
        return 0
    if d[n][m][k] > 0:
        return d[n][m][k]
    if n*m<k:
        return 10**10
    cost = 10**10
    for i in range(1, n // 2 + 1):
        for j in range(k+1):
            cost = min(cost, m*m + rec(n-i, m, k-j) + rec(i, m, j))
    for i in range(1, m // 2 + 1):
        for j in range(k+1):
            cost = min(cost, n*n + rec(n, m-i, k-j) + rec(n, i, j))
    d[n][m][k] = cost
    return cost

p = []
t = int(input())
for i in range(t):
    n, m, k = map(int, input().split())
    p.append(rec(n, m, k))
print('\n'.join(str(x) for x in p))

d = [ [ [ 0 for i in range(51) ] for j in range(31) ] for g in range(31)]
def rec(n, m ,k):
    nonlocal d
    if k == 0 or n*m == k:
        return 0
    if d[n][m][k] > 0 :
        return d[n][m][k]
    if n * m < k:
        return 10 ** 10
    cost  = 10**10
    for i in range(1, n//2 +1):
        for j in range(k+1):
            cost = min(cost, m**2 + rec(i, m, j) + rec(n-i, m, k-j))
    for i in range(1, m//2 +1):
        for j in range(0, k+1):
            cost = min(cost, n**2 + rec(n, i, j) + rec(n, m-i, k-j))
    d[n][m][k] = cost
    return cost
t = int(input())
a = []
for c in range(t):
    n, m ,k = map(int, input().split())
    a.append(rec(n,m,k))
print('\n'.join(str(x) for x in a))

t=int(input())
d=[]
for i in range(31):
    dd=[]
    for j in range(31):
        dd.append([0]*51)
    d.append(dd)
d[1][1][1]=0
for i in range(1,31):
    for j in range(1,31):
        for k in range(1,min(i*j,50)+1):
            if k>i*j//2:
                d[i][j][k]=d[i][j][i*j-k]
            elif i>j:
                d[i][j][k]=d[j][i][k]
            elif (i,j)!=(1,1):
                k=min(k,i*j-k)
                kk=i*j-k
                jj=(i**2*j)*(j**2)*i
                for l in range(1,i):
                    if k<=l*j:
                        jj=min(jj,d[l][j][k]+j**2)
                    else:
                        k1=k-l*j
                        jj=min(jj,d[i-l][j][k1]+j**2)
                    if kk<=l*j:
                        if kk<=50:
                            jj=min(jj,d[l][j][kk]+j**2)
                    else:
                        kk1=kk-l*j
                        if kk1<=50:
                            jj=min(jj,d[i-l][j][kk1]+j**2)
                for l in range(1,j):
                    if k<=l*i:
                        jj=min(jj,d[i][l][k]+i**2)
                    else:
                        k1=k-l*i
                        jj=min(jj,d[i][j-l][k1]+i**2)
                    if kk<=l*i:
                        if kk<=50:
                            jj=min(jj,d[i][l][kk]+i**2)
                    else:
                        kk1=kk-l*i
                        if kk1<=50:
                            jj=min(jj,d[i][j-l][kk1]+i**2)
                d[i][j][k]=jj
for i in range(t):
    n,m,k=list(map(int,input().split()))
    jj=d[n][m][k]
    print(jj)


mem = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]


def f(n, m, k):
    if mem[n][m][k]:
        return mem[n][m][k]
    if (n*m == k) or (k == 0):
        return 0
    cost = 10**9
    for x in range(1, n//2 + 1):
        for z in range(k+1):
            cost = min(cost, m*m + f(n-x, m, k-z) + f(x, m, z))
    for y in range(1, m//2 + 1):
        for z in range(k+1):
            cost = min(cost, n*n + f(n, m-y, k-z) + f(n, y, z))
    mem[n][m][k] = cost
    return cost


t = int(input())
for i in range(t):
    n, m, k = map(int, input().split())
    print(f(n, m, k))

t = int(input())

dp = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]

def cost(n, m, k):
    if (dp[n][m][k] or k == 0 or n * m == k): return dp[n][m][k]
    c = 10**9
    for i in range(1, n // 2 + 1):
        for j in range(k + 1):
            c = min(c, cost(n - i, m, k - j) + cost(i, m, j) + m * m)
    for i in range(1, m // 2 + 1):
        for j in range(k + 1):
            c = min(c, cost(n, m - i, k - j) + cost(n, i, j) + n * n)
    dp[n][m][k] = c
    return c

for _ in range(t):
    n, m, k = list(map(int, input().split()))
    print(cost(n, m, k))

# mem = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]


# def f(n, m, k):
#     if mem[n][m][k]:
#         return mem[n][m][k]
#     if (n*m == k) or (k == 0):
#         return 0
#     cost = 10**9
#     for x in range(1, n//2 + 1):
#         for z in range(k+1):
#             cost = min(cost, m*m + f(n-x, m, k-z) + f(x, m, z))
#     for y in range(1, m//2 + 1):
#         for z in range(k+1):
#             cost = min(cost, n*n + f(n, m-y, k-z) + f(n, y, z))
#     mem[n][m][k] = cost
#     return cost


# t = int(input())
# for i in range(t):
#     n, m, k = map(int, input().split())
#     print(f(n, m, k))


t = int(input())

dp = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]

def cost(n, m, k):
    if (dp[n][m][k] or k == 0 or n * m == k): return dp[n][m][k]
    c = 10**9
    for i in range(1, n // 2 + 1):
        for j in range(k + 1):
            c = min(c, cost(i, m, j) + cost(n - i, m, k - j) + m * m)
    for i in range(1, m // 2 + 1):
        for j in range(k + 1):
            c = min(c, cost(n, i, j) + cost(n, m - i, k - j) + n * n)
    dp[n][m][k] = c
    return c

for _ in range(t):
    n, m, k = list(map(int, input().split()))
    print(cost(n, m, k))



D = {}


def h(m,n,answ,k):
    x = answ
    for i in range(1,(n+2)//2):
        if k >= i*m:
            if m**2+ans(m,n-i,k-i*m) < x:
                x = m**2+ans(m,n-i,k-i*m)
        if k <= (n-i)*m:
            if m**2+ans(m,n-i,k) < x:
                x = m**2+ans(m,n-i,k)
        if k >= (n-i)*m:
            if m**2+ans(m,i,k-(n-i)*m) < x:
                x = m**2+ans(m,i,k-(n-i)*m)
        if k <= i*m:
            if m**2+ans(m,i,k) < x :
                x = m**2+ans(m,i,k)
    return x
def ans(m,n,k):
    if k == 0:
        D[(m,n,k)] = 0
        D[(n,m,k)] = 0
        return 0
    if m*n == k:
        D[(m,n,k)] = 0
        D[(n,m,k)] = 0
        return 0
    elif m == 1:
        D[(m,n,k)] = 1
        D[(n,m,k)] = 1
        return 1
    elif n == 1:
        D[(m,n,k)] = 1
        D[(n,m,k)] = 1
        return 1
    elif (m,n,k) in D:
        return D[(m,n,k)]
    else:
        answ = (n**2)*m
        t = h(m,n,answ,k)
        if t < answ:
            answ = t
        s = h(n,m,answ,k)
        if s < answ:
            answ = s
        D[(m,n,k)] = answ
        D[(n,m,k)] = answ
        return answ

for i in range(30,0,-1):
    for j in range(i,0,-1):
        for k in range(0,min(i*j,50)+1):
            ans(i,j,k)

t = int(input())

for i in range(t):
    m,n,k = [int(x) for x in input().split()]
    print(D[(m,n,k)])

import sys
input=sys.stdin.readline
def main():
	ans=[]
	memo=[[[-1 for _ in range(51)] for _ in range(31)] for _ in range(31)]
	def  solve(n, m , k) :
		if n*m == k or k==0: return 0
		if memo[n][m][k] > -1 : return memo[n][m][k]
		if memo[m][n][k] > -1 : memo[n][m][k]=memo[m][n][k] ; return memo[n][m][k]
		r=float('inf')
		for i in range(k+1):
			for j in range(1,max(m,n)):
				if m > j :
					r=min(r,n**2+solve(j,n,i)+solve(m-j,n,k-i))
				if n > j :
					r=min(r,m**2+solve(m,j,i)+solve(m,n-j,k-i))
		memo[n][m][k] = r
		return r
	for _ in range(int(input())):
		n,m,k = map(int,input().split())
		ans.append(str(solve(n,m,k)))
	print('\n'.join(ans))
main()

t = int(input())
d = []
for i in range(31):
    dd = []
    for j in range(31):
        dd.append([0] * 51)
    d.append(dd)
d[1][1][1] = 0
for i in range(1, 31):
    for j in range(1, 31):
        for k in range(1, min(i * j, 50) + 1):
            if k > i * j // 2:
                d[i][j][k] = d[i][j][i * j - k]
            elif i > j:
                d[i][j][k] = d[j][i][k]
            elif (i, j) != (1, 1):
                k = min(k, i * j - k)
                kk = i * j - k
                jj = (i ** 2 * j) * (j ** 2) * i
                for l in range(1, i):
                    if k <= l * j:
                        jj = min(jj, d[l][j][k] + j ** 2)
                    else:
                        k1 = k - l * j
                        jj = min(jj, d[i - l][j][k1] + j ** 2)
                    # if kk <= l * j:
                    #     if kk <= 50:
                    #         jj = min(jj, d[l][j][kk] + j ** 2)
                    # else:
                    #     kk1 = kk - l * j
                    #     if kk1 <= 50:
                    #         jj = min(jj, d[i - l][j][kk1] + j ** 2)
                for l in range(1, j):
                    if k <= l * i:
                        jj = min(jj, d[i][l][k] + i ** 2)
                    else:
                        k1 = k - l * i
                        jj = min(jj, d[i][j - l][k1] + i ** 2)
                    # if kk <= l * i:
                    #     if kk <= 50:
                    #         jj = min(jj, d[i][l][kk] + i ** 2)
                    # else:
                    #     kk1 = kk - l * i
                    #     if kk1 <= 50:
                    #         jj = min(jj, d[i][j - l][kk1] + i ** 2)
                d[i][j][k] = jj
for i in range(t):
    n, m, k = list(map(int, input().split()))
    jj = d[n][m][k]
    print(jj)
# print(d[3][3][2])


dp = {}


def getDP(n, m, k):
    if (n, m, k) in dp:
        return dp[(n, m, k)]
    elif (m, n, k) in dp:
        return dp[(m, n, k)]
    return None


def solve(n, m, k):
    if n == 2 and m == 3 and k == 5:
        h = 5
    if k == m * n or k == 0:
        dp[(n, m, k)] = 0
    elif k % min(n, m) == 0:
        dp[(n, m, k)] = min(n, m) ** 2
    elif k == 1:
        dp[(n, m, k)] = min(n, m) ** 2 + 1
    elif getDP(n, m, k) is not None:
        return getDP(n, m, k)
    else:
        bestAns = float('inf')
        for i in range(1, n):
            if k <= i * m:
                bestAns = min(bestAns, getDP(i, m, k) + m ** 2)
            else:
                bestAns = min(bestAns, getDP(n - i, m, k - i * m) + m ** 2)

        for i in range(1, m):
            if k <= i * n:
                bestAns = min(bestAns, getDP(i, n, k) + n ** 2)
            else:
                bestAns = min(bestAns, getDP(m - i, n, k - i * n) + n ** 2)
        dp[(n, m, k)] = bestAns


for i in range(1, 31):
    for j in range(1, 31):
        for k in range(min(i * j, 50) + 1):
            solve(i, j, k)
toPrint = []
t = int(input())
for i in range(t):
    n, m, k = [int(x) for x in input().split(" ")]
    toPrint.append(getDP(n, m, k))

for x in toPrint:
    print(x)


import sys
input = sys.stdin.readline

d={}
testnumber = int(input())

def calc(n, m, k):
    if k <= 0 or k == m*n:
        return 0
    if k > n*m:
        return 1000_000_000

    nonlocal d
    if n < m:
        n, m = m, n
    
    if k > (m*n - m):
        return m*m + 1
    if k < m:
        return m*m + 1
    if k % m == 0:
        return m*m

    if (n, m, k) in d:
        return d[ (n, m, k)]

    d[ (n, m, k) ] = min( calc2(n, m, k), calc2(m, n, k) )

    return d[ (n, m, k) ]

def calc2(n, m, k):
    m2 = m*m
    ans = m2*2 + 1
    for i in range(1, n):
        if i*m >= k:
            ans = min(ans, m2 + calc(m, i, k) )
        else:
            ans = min(ans, m2 + calc(m, n-i, k - i*m))
    
    return ans

for ntest in range(testnumber):
    n, m, k = map( int, input().split() )
    if k == n*m:
        print(0)
        continue

    print( calc(n, m, k) )

import sys
input = sys.stdin.readline

d={}
testnumber = int(input())

def calc(n, m, k):
    if k <= 0 or k == m*n:
        return 0
    if k > n*m:
        return 1000_000_000

    nonlocal d
    if n < m:
        n, m = m, n
    
    if k > (m*n - m):
        return m*m + 1
    if k < m:
        return m*m + 1
    if k % m == 0:
        return m*m

    if (n, m, k) in d:
        return d[ (n, m, k)]

    d[ (n, m, k) ] = min( calc2(n, m, k), calc2(m, n, k) )

    return d[ (n, m, k) ]

def calc2(n, m, k):
    m2 = m*m
    ans = m2*2 + 1
    for i in range(1, n):
        if i*m >= k:
            ans = min(ans, m2 + calc(m, i, k) )
        else:
            ans = min(ans, m2 + calc(m, n-i, k - i*m))
    
    return ans

for ntest in range(testnumber):
    n, m, k = map( int, input().split() )
    if k == n*m:
        print(0)
        continue

    print( calc(n, m, k) )

d=[[[0 for i in range(51)] for j in range(31)] for k in range(31)]

for i in range(31):
    d.append([])
    for j in range(31):
        d[i].append([])
        for k in range(50):
            d[i][j].append(0)

    
def rec(n,m,k):
    nonlocal d
    if n*m==k or k==0:
        return 0
    if d[n][m][k]>0:
        return d[n][m][k]
    if n*m<k:
        return 10**10
    cost=10**10
    for i in range(1,n//2+1):
        for j in range(k+1):
            cost=min(cost,m*m+rec(n-i,m,k-j)+rec(i,m,j))
    for i in range(1,m//2+1):
        for j in range(k+1):
            cost=min(cost,n*n+rec(n,m-i,k-j)+rec(n,i,j))
            
    d[n][m][k]=cost
    return cost
    
for i in range(int(input())):
    a,b,c=list(map(int,input().split()))
    print(rec(a,b,c))


d=[[[0 for i in range(51)] for j in range(31)] for k in range(31)]
    
def rec(n,m,k):
    nonlocal d
    if n*m==k or k==0:
        return 0
    if d[n][m][k]>0:
        return d[n][m][k]
    if n*m<k:
        return 10**10
    cost=10**10
    for i in range(1,n//2+1):
        for j in range(k+1):
            cost=min(cost,m*m+rec(n-i,m,k-j)+rec(i,m,j))
    for i in range(1,m//2+1):
        for j in range(k+1):
            cost=min(cost,n*n+rec(n,m-i,k-j)+rec(n,i,j))
            
    d[n][m][k]=cost
    return cost
    
for i in range(int(input())):
    a,b,c=list(map(int,input().split()))
    print(rec(a,b,c))