You are given a simple weighted connected undirected graph, consisting of $n$ vertices and $m$ edges.

A path in the graph of length $k$ is a sequence of $k+1$ vertices $v_1, v_2, \dots, v_{k+1}$ such that for each $i$ $(1 \le i \le k)$ the edge $(v_i, v_{i+1})$ is present in the graph. A path from some vertex $v$ also has vertex $v_1=v$. Note that edges and vertices are allowed to be included in the path multiple times.

The weight of the path is the total weight of edges in it.

For each $i$ from $1$ to $q$ consider a path from vertex $1$ of length $i$ of the maximum weight. What is the sum of weights of these $q$ paths?

Answer can be quite large, so print it modulo $10^9+7$.


-----Input-----

The first line contains a three integers $n$, $m$, $q$ ($2 \le n \le 2000$; $n - 1 \le m \le 2000$; $m \le q \le 10^9$) — the number of vertices in the graph, the number of edges in the graph and the number of lengths that should be included in the answer.

Each of the next $m$ lines contains a description of an edge: three integers $v$, $u$, $w$ ($1 \le v, u \le n$; $1 \le w \le 10^6$) — two vertices $v$ and $u$ are connected by an undirected edge with weight $w$. The graph contains no loops and no multiple edges. It is guaranteed that the given edges form a connected graph.


-----Output-----

Print a single integer — the sum of the weights of the paths from vertex $1$ of maximum weights of lengths $1, 2, \dots, q$ modulo $10^9+7$.


-----Examples-----
Input
7 8 25
1 2 1
2 3 10
3 4 2
1 5 2
5 6 7
6 4 15
5 3 1
1 7 3

Output
4361

Input
2 1 5
1 2 4

Output
60

Input
15 15 23
13 10 12
11 14 12
2 15 5
4 10 8
10 2 4
10 7 5
3 10 1
5 6 11
1 13 8
9 15 4
4 2 9
11 15 1
11 12 14
10 8 12
3 6 11

Output
3250

Input
5 10 10000000
2 4 798
1 5 824
5 2 558
4 1 288
3 4 1890
3 1 134
2 3 1485
4 5 284
3 5 1025
1 2 649

Output
768500592



-----Note-----

Here is the graph for the first example: [Image] 

Some maximum weight paths are:   length $1$: edges $(1, 7)$ — weight $3$;  length $2$: edges $(1, 2), (2, 3)$ — weight $1+10=11$;  length $3$: edges $(1, 5), (5, 6), (6, 4)$ — weight $2+7+15=24$;  length $4$: edges $(1, 5), (5, 6), (6, 4), (6, 4)$ — weight $2+7+15+15=39$;  $\dots$ 

So the answer is the sum of $25$ terms: $3+11+24+39+\dots$

In the second example the maximum weight paths have weights $4$, $8$, $12$, $16$ and $20$.

Difficulty: interview

Starter code:

Solutions:
import sys
input = sys.stdin.readline
#lev contains height from root,lower neighbour, higher neighbours
#lev[0] contains 0 (because it is the root), higher neighbours (=neighbours)
n,m,q=map(int,input().split())
mod=1000000007
mxw=0
wgts=[0]*n
neig=[0]*n
for i in range(n):
    neig[i]=[0]

for i in range(m):
    a,b,w=map(int,input().split())
    a-=1
    b-=1
    neig[a][0]+=1
    neig[b][0]+=1
    neig[a].append([b,w])
    neig[b].append([a,w])
    mxw=max(mxw,w)
    wgts[a]=max(wgts[a],w)
    wgts[b]=max(wgts[b],w)
poss=[-1]*n
poss[0]=0
sol=0
curw=0
hasmxw=[False]*n
for i in range(n):
    if wgts[i]==mxw:
        hasmxw[i]=True
ov=False
l=0
while l<q and not ov and l<3000:
    newposs=[-1]*n
    for i in range(n):
        if poss[i]>=0:
            for j in range(1,neig[i][0]+1):
                newposs[neig[i][j][0]]=max(newposs[neig[i][j][0]],poss[i]+neig[i][j][1])
    curmx=0
    for i in range(n):
        poss[i]=newposs[i]
        if poss[i]>curmx:
            curmx=poss[i]
            ov=hasmxw[i]
        else:
            if poss[i]==curmx and hasmxw[i]:
                ov=True
    curw=curmx
    sol+=curw
    sol%=mod
    l+=1
if l==q:
    print(sol)
else:
    if ov:
        rem=q-l
        sol+=rem*curw
        sol%=mod
        sol+=mxw*((rem*(rem+1))//2)
        sol%=mod
        print(sol)
    else:
        rem=q-l
        while not ov:
            mx=0
            for i in range(n):
                if poss[i]==curw:
                    mx=max(mx,wgts[i])
            gd=-1
            for i in range(n):
                if wgts[i]>mx and poss[i]>=0:
                    diff=wgts[i]-mx
                    loss=curw-poss[i]
                    loss+=diff-1
                    att=loss//diff
                    if gd==-1:
                        gd=att
                    gd=min(att,gd)
            if gd==-1 or gd>rem:
                sol+=rem*curw
                sol+=mx*((rem*(rem+1))//2)
                sol%=mod
                ov=True
            else:
                sol+=(gd-1)*curw
                sol+=mx*((gd*(gd-1))//2)
                sol%=mod
                for i in range(n):
                    poss[i]+=gd*wgts[i]
                    curw=max(curw,poss[i])
                sol+=curw
                rem-=gd
        print(sol)

import sys
input = sys.stdin.readline
#lev contains height from root,lower neighbour, higher neighbours
#lev[0] contains 0 (because it is the root), higher neighbours (=neighbours)
n,m,q=map(int,input().split())
mod=1000000007
mxw=0
wgts=[0]*n
neig=[0]*n
for i in range(n):
    neig[i]=[0]

for i in range(m):
    a,b,w=map(int,input().split())
    a-=1
    b-=1
    neig[a][0]+=1
    neig[b][0]+=1
    neig[a].append([b,w])
    neig[b].append([a,w])
    mxw=max(mxw,w)
    wgts[a]=max(wgts[a],w)
    wgts[b]=max(wgts[b],w)
poss=[-1]*n
poss[0]=0
sol=0
curw=0
hasmxw=[False]*n
for i in range(n):
    if wgts[i]==mxw:
        hasmxw[i]=True
ov=False
l=0
while l<q and not ov and l<3000:
    newposs=[-1]*n
    for i in range(n):
        if poss[i]>=0:
            for j in range(1,neig[i][0]+1):
                newposs[neig[i][j][0]]=max(newposs[neig[i][j][0]],poss[i]+neig[i][j][1])
    curmx=0
    for i in range(n):
        poss[i]=newposs[i]
        if poss[i]>curmx:
            curmx=poss[i]
            ov=hasmxw[i]
        else:
            if poss[i]==curmx and hasmxw[i]:
                ov=True
    curw=curmx
    sol+=curw
    sol%=mod
    l+=1
if l==q:
    print(sol)
else:
    if ov:
        rem=q-l
        sol+=rem*curw
        sol%=mod
        sol+=mxw*((rem*(rem+1))//2)
        sol%=mod
        print(sol)
    else:
        rem=q-l
        while not ov:
            mx=0
            for i in range(n):
                if poss[i]==curw:
                    mx=max(mx,wgts[i])
            gd=-1
            for i in range(n):
                if wgts[i]>mx and poss[i]>=0:
                    diff=wgts[i]-mx
                    loss=curw-poss[i]
                    loss+=diff-1
                    att=loss//diff
                    if gd==-1:
                        gd=att
                    gd=min(att,gd)
            if gd==-1 or gd>rem:
                sol+=rem*curw
                sol+=mx*((rem*(rem+1))//2)
                sol%=mod
                ov=True
            else:
                sol+=(gd-1)*curw
                sol+=mx*((gd*(gd-1))//2)
                sol%=mod
                for i in range(n):
                    poss[i]+=gd*wgts[i]
                    curw=max(curw,poss[i])
                sol+=curw
                rem-=gd
        print(sol)

import sys
input = sys.stdin.readline
n,m,q=map(int,input().split())
mod=1000000007
mxw=0
wgts=[0]*n
neig=[0]*n
for i in range(n):
    neig[i]=[0]

for i in range(m):
    a,b,w=map(int,input().split())
    a-=1;b-=1;neig[a][0]+=1;neig[b][0]+=1;neig[a].append([b,w]);neig[b].append([a,w])
    mxw=max(mxw,w);wgts[a]=max(wgts[a],w);wgts[b]=max(wgts[b],w)
poss=[-1]*n;poss[0]=0;sol=0;curw=0;hasmxw=[False]*n
for i in range(n):
    if wgts[i]==mxw:hasmxw[i]=True
ov=False
l=0
while l<q and not ov and l<3000:
    newposs=[-1]*n
    for i in range(n):
        if poss[i]>=0:
            for j in range(1,neig[i][0]+1):
                newposs[neig[i][j][0]]=max(newposs[neig[i][j][0]],poss[i]+neig[i][j][1])
    curmx=0
    for i in range(n):
        poss[i]=newposs[i]
        if poss[i]>curmx:curmx=poss[i];ov=hasmxw[i]
        else:
            if poss[i]==curmx and hasmxw[i]:ov=True
    curw=curmx;sol+=curw;sol%=mod;l+=1
if l==q:print(sol)
else:
    if ov:
        rem=q-l
        sol+=rem*curw
        sol%=mod
        sol+=mxw*((rem*(rem+1))//2)
        sol%=mod
        print(sol)
    else:
        rem=q-l
        while not ov:
            mx=0
            for i in range(n):
                if poss[i]==curw:mx=max(mx,wgts[i])
            gd=-1
            for i in range(n):
                if wgts[i]>mx and poss[i]>=0:
                    diff=wgts[i]-mx
                    loss=curw-poss[i]
                    loss+=diff-1
                    att=loss//diff
                    if gd==-1:
                        gd=att
                    gd=min(att,gd)
            if gd==-1 or gd>rem:sol+=rem*curw;sol+=mx*((rem*(rem+1))//2);sol%=mod;ov=True
            else:
                sol+=(gd-1)*curw;sol+=mx*((gd*(gd-1))//2);sol%=mod
                for i in range(n):poss[i]+=gd*wgts[i];curw=max(curw,poss[i])
                sol+=curw;rem-=gd
        print(sol)

import sys
n,m,q=map(int,input().split())
mod,mxw = 1000000007,0;wgts,neig=[0]*n,[0]*n
for i in range(n):
    neig[i]=[0]

for i in range(m):
    a,b,w=map(int,input().split())
    a-=1;b-=1;neig[a][0]+=1;neig[b][0]+=1;neig[a].append([b,w]);neig[b].append([a,w])
    mxw=max(mxw,w);wgts[a]=max(wgts[a],w);wgts[b]=max(wgts[b],w)
poss=[-1]*n;poss[0]=0;sol=0;curw=0;hasmxw=[False]*n
for i in range(n):
    if wgts[i]==mxw:hasmxw[i]=True
ov=False;l=0
while l<q and not ov and l<3000:
    newposs=[-1]*n;curmx=0
    for i in range(n):
        if poss[i]>=0:
            for j in range(1,neig[i][0]+1):newposs[neig[i][j][0]]=max(newposs[neig[i][j][0]],poss[i]+neig[i][j][1])    
    for i in range(n):
        poss[i]=newposs[i]
        if poss[i]>curmx:curmx=poss[i];ov=hasmxw[i]
        else:
            if poss[i]==curmx and hasmxw[i]:ov=True
    curw=curmx;sol+=curw;sol%=mod;l+=1
if l==q:print(sol)
else:
    if ov:rem=q-l;sol+=rem*curw;sol%=mod;sol+=mxw*((rem*(rem+1))//2);sol%=mod;print(sol)
    else:
        rem=q-l
        while not ov:
            mx=0;gd=-1
            for i in range(n):
                if poss[i]==curw:mx=max(mx,wgts[i])            
            for i in range(n):
                if wgts[i]>mx and poss[i]>=0:
                    diff=wgts[i]-mx;loss=curw-poss[i];loss+=diff-1;att=loss//diff
                    if gd==-1:gd=att
                    gd=min(att,gd)
            if gd==-1 or gd>rem:sol+=rem*curw;sol+=mx*((rem*(rem+1))//2);sol%=mod;ov=True
            else:
                sol+=(gd-1)*curw;sol+=mx*((gd*(gd-1))//2);sol%=mod
                for i in range(n):poss[i]+=gd*wgts[i];curw=max(curw,poss[i])
                sol+=curw;rem-=gd
        print(sol)

n,m,q=map(int,input().split());mod,mxw = 1000000007,0;wgts,neig=[0]*n,[0]*n
for i in range(n):neig[i]=[0]
for i in range(m):a,b,w=map(int,input().split());a-=1;b-=1;neig[a][0]+=1;neig[b][0]+=1;neig[a].append([b,w]);neig[b].append([a,w]);mxw=max(mxw,w);wgts[a]=max(wgts[a],w);wgts[b]=max(wgts[b],w)
poss=[-1]*n;poss[0]=0;sol=0;curw=0;hasmxw=[False]*n
for i in range(n):
    if wgts[i]==mxw:hasmxw[i]=True
ov=False;l=0
while l<q and not ov and l<3000:
    newposs=[-1]*n;curmx=0
    for i in range(n):
        if poss[i]>=0:
            for j in range(1,neig[i][0]+1):newposs[neig[i][j][0]]=max(newposs[neig[i][j][0]],poss[i]+neig[i][j][1])    
    for i in range(n):
        poss[i]=newposs[i]
        if poss[i]>curmx:curmx=poss[i];ov=hasmxw[i]
        else:
            if poss[i]==curmx and hasmxw[i]:ov=True
    curw=curmx;sol+=curw;sol%=mod;l+=1
if l==q:print(sol)
else:
    if ov:rem=q-l;sol+=rem*curw;sol%=mod;sol+=mxw*((rem*(rem+1))//2);sol%=mod;print(sol)
    else:
        rem=q-l
        while not ov:
            mx=0;gd=-1
            for i in range(n):
                if poss[i]==curw:mx=max(mx,wgts[i])            
            for i in range(n):
                if wgts[i]>mx and poss[i]>=0:
                    diff=wgts[i]-mx;loss=curw-poss[i];loss+=diff-1;att=loss//diff
                    if gd==-1:gd=att
                    gd=min(att,gd)
            if gd==-1 or gd>rem:sol+=rem*curw;sol+=mx*((rem*(rem+1))//2);sol%=mod;ov=True
            else:
                sol+=(gd-1)*curw;sol+=mx*((gd*(gd-1))//2);sol%=mod
                for i in range(n):poss[i]+=gd*wgts[i];curw=max(curw,poss[i])
                sol+=curw;rem-=gd
        print(sol)

import sys
input = sys.stdin.readline
n, m, q = list(map(int, input().split()))

MOD = 10 ** 9 + 7

edges = []
adj = [[] for _ in range(n)]

for i in range(m):
	a, b, w = list(map(int, input().split()))
	a -= 1
	b -= 1
	edges.append((a, b, w))
	adj[a].append((b, w))
	adj[b].append((a, w))


INF = 10 ** 18

ans = 0

DP = [-INF] * n
DP[0] = 0

# Paths are at most m long
for plen in range(m):
	NDP = [-INF] * n

	for i in range(n):
		for j, w in adj[i]:
			NDP[j] = max(NDP[j], DP[i] + w)

	DP = NDP
	ans = (ans + max(DP)) % MOD

#print(ans)
#print(DP)
#assert all(v > 0 for v in DP)


""" From PyRival """
def convex_hull_trick(K, M, integer = True):
    """
    Given lines on the form y = K[i] * x + M[i] this function returns intervals,
    such that on each interval the convex hull is made up of a single line.
    Input:
        K: list of the slopes
        M: list of the constants (value at x = 0)
        interger: boolean for turning on / off integer mode. Integer mode is exact, it
                  works by effectively flooring the seperators of the intervals.
    Return:
        hull_i: on interval j, line i = hull_i[j] is >= all other lines
        hull_x: interval j and j + 1 is separated by x = hull_x[j], (hull_x[j] is the last x in interval j)
    """
    if integer:
        intersect = lambda i,j: (M[j] - M[i]) // (K[i] - K[j])
    else:
        intersect = lambda i,j: (M[j] - M[i]) / (K[i] - K[j])

    assert len(K) == len(M)

    hull_i = []
    hull_x = []
    order = sorted(list(range(len(K))), key = K.__getitem__)
    for i in order:
        while True:
            if not hull_i:
                hull_i.append(i)
                break
            elif K[hull_i[-1]] == K[i]:
                if M[hull_i[-1]] >= M[i]:
                    break
                hull_i.pop()
                if hull_x: hull_x.pop()
            else:
                x = intersect(i, hull_i[-1])
                if hull_x and x <= hull_x[-1]:
                    hull_i.pop()
                    hull_x.pop()
                else:
                    hull_i.append(i)
                    hull_x.append(x)
                    break
    return hull_i, hull_x


nedges = []
slope, intersect = [], []
for a, b, w in edges:
	i = max(a, b, key=lambda i: DP[i])

	assert DP[i] > 0

	#print(f'edge ({a+1}, {b+1}, {w}) usable from {usable_from} with distance {w_at_time}', file=sys.stderr)
	slope.append(w)
	intersect.append(DP[i])
	nedges.append((DP[i], w))

# For each edge, figure out the interval in which it is the best option
hull_i, hull_x = convex_hull_trick(slope, intersect)

#print(hull_i)
#print(hull_x)

def tri(x):
	return (x * (x + 1)) // 2

lt = 0
for i, j in enumerate(hull_i):
	wt, w = nedges[j]

	until = min(q if i == len(hull_x) else hull_x[i], q - m)

	if until <= 0: continue

	active = (until - lt)
	#assert us <= lt
	#assert until > lt, (until, lt)

	ans = (ans + active * wt) % MOD

	min_uses = lt
	max_uses = lt + active

	times = tri(max_uses) - tri(min_uses)
	ans = (ans + times * w) % MOD

	#print(f'since {lt} to {until} use {(wt, w)} from {min_uses} to {max_uses} ({times}) times')
	#print(ans)

	lt = until
	if lt == q - m: break

print(ans)



import sys
input = sys.stdin.readline
n, m, q = list(map(int, input().split()))

MOD = 10 ** 9 + 7

edges = []
adj = [[] for _ in range(n)]

for i in range(m):
	a, b, w = list(map(int, input().split()))
	a -= 1
	b -= 1
	edges.append((a, b, w))
	adj[a].append((b, w))
	adj[b].append((a, w))


INF = 10 ** 18
ans = 0

DP = [-INF] * n
DP[0] = 0

# Paths are at most m long
for plen in range(m):
	NDP = [-INF] * n

	for a, b, w in edges:
		NDP[b] = max(NDP[b], DP[a] + w)
		NDP[a] = max(NDP[a], DP[b] + w)

	DP = NDP
	ans = (ans + max(DP)) % MOD

""" From PyRival """
def convex_hull_trick(K, M, integer = True):
    """
    Given lines on the form y = K[i] * x + M[i] this function returns intervals,
    such that on each interval the convex hull is made up of a single line.
    Input:
        K: list of the slopes
        M: list of the constants (value at x = 0)
        interger: boolean for turning on / off integer mode. Integer mode is exact, it
                  works by effectively flooring the seperators of the intervals.
    Return:
        hull_i: on interval j, line i = hull_i[j] is >= all other lines
        hull_x: interval j and j + 1 is separated by x = hull_x[j], (hull_x[j] is the last x in interval j)
    """
    if integer:
        intersect = lambda i,j: (M[j] - M[i]) // (K[i] - K[j])
    else:
        intersect = lambda i,j: (M[j] - M[i]) / (K[i] - K[j])

    assert len(K) == len(M)

    hull_i = []
    hull_x = []
    order = sorted(list(range(len(K))), key = K.__getitem__)
    for i in order:
        while True:
            if not hull_i:
                hull_i.append(i)
                break
            elif K[hull_i[-1]] == K[i]:
                if M[hull_i[-1]] >= M[i]:
                    break
                hull_i.pop()
                if hull_x: hull_x.pop()
            else:
                x = intersect(i, hull_i[-1])
                if hull_x and x <= hull_x[-1]:
                    hull_i.pop()
                    hull_x.pop()
                else:
                    hull_i.append(i)
                    hull_x.append(x)
                    break
    return hull_i, hull_x


slope, intersect = [], []
for a, b, w in edges:
	i = max(a, b, key=lambda i: DP[i])
	assert DP[i] > 0

	#print(f'edge ({a+1}, {b+1}, {w}) usable from {usable_from} with distance {w_at_time}', file=sys.stderr)
	slope.append(w)
	intersect.append(DP[i])

# For each edge, figure out the interval in which it is the best option
hull_i, hull_x = convex_hull_trick(slope, intersect)

#print(hull_i)
#print(hull_x)

def tri(x):
	return (x * (x + 1)) // 2

lt = 0
for i, j in enumerate(hull_i):
	wt, w = intersect[j], slope[j]

	until = min(q if i == len(hull_x) else hull_x[i], q - m)

	if until <= 0: continue

	active = (until - lt)
	ans = (ans + active * wt) % MOD

	min_uses = lt
	max_uses = lt + active

	times = tri(max_uses) - tri(min_uses)
	ans = (ans + times * w) % MOD

	#print(f'since {lt} to {until} use {(wt, w)} from {min_uses} to {max_uses} ({times}) times')
	#print(ans)

	lt = until
	if lt == q - m: break

print(ans)



import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')


MOD = 10 ** 9 + 7
INF = 100


def convex_hull_trick(K, M, integer=True):
    """
    Given lines on the form y = K[i] * x + M[i] this function returns intervals,
    such that on each interval the convex hull is made up of a single line.
    Input:
        K: list of the slopes
        M: list of the constants (value at x = 0)
        interger: boolean for turning on / off integer mode. Integer mode is exact, it
                  works by effectively flooring the seperators of the intervals.
    Return:
        hull_i: on interval j, line i = hull_i[j] is >= all other lines
        hull_x: interval j and j + 1 is separated by x = hull_x[j], (hull_x[j] is the last x in interval j)
    """
    if integer:
        intersect = lambda i, j: (M[j] - M[i]) // (K[i] - K[j])
    else:
        intersect = lambda i, j: (M[j] - M[i]) / (K[i] - K[j])

    assert len(K) == len(M)

    hull_i = []
    hull_x = []
    order = sorted(list(range(len(K))), key=K.__getitem__)
    for i in order:
        while True:
            if not hull_i:
                hull_i.append(i)
                break
            elif K[hull_i[-1]] == K[i]:
                if M[hull_i[-1]] >= M[i]:
                    break
                hull_i.pop()
                if hull_x: hull_x.pop()
            else:
                x = intersect(i, hull_i[-1])
                if hull_x and x <= hull_x[-1]:
                    hull_i.pop()
                    hull_x.pop()
                else:
                    hull_i.append(i)
                    hull_x.append(x)
                    break
    return hull_i, hull_x


def nn2(n):
    return n * (n+1) // 2


def solve(n, m, q, edges):
    # k < m
    # dp[v][k] - max path cost ending in v and having k edges
    dp = [[-INF]*(m+1) for _ in range(n)]
    mk = [0]*(m+1)

    dp[0][0] = 0

    for k in range(1, m+1):
        for e in edges:
            if dp[e[0]][k-1] == -INF:
                continue
            dp[e[1]][k] = max(dp[e[1]][k], dp[e[0]][k-1] + e[2])
            mk[k] = max(mk[k], dp[e[1]][k])

    ans = sum(mk) % MOD
    if q > m:
        intersect = [dp[i][m] for i in range(n)]
        slope = [0] * n

        for e in edges:
            if e[2] > slope[e[0]]:
                slope[e[0]] = e[2]

        hull_i, hull_x = convex_hull_trick(slope, intersect)

        lt = 0
        for i, j in enumerate(hull_i):
            wt = intersect[j]
            w = slope[j]

            until = min(q if i == len(hull_x) else hull_x[i], q - m)
            if until <= 0:
                continue

            active = (until - lt)

            ans = (ans + active * wt) % MOD

            min_uses = lt
            max_uses = lt + active

            times = nn2(max_uses) - nn2(min_uses)
            ans = (ans + times * w) % MOD

            lt = until
            if lt == q - m: break


    return ans

def main():
    n, m, q = ria()
    e = []
    for _ in range(m):
        u, v, w = ria()
        u -= 1
        v -= 1
        e.append((u, v, w))
        e.append((v, u, w))
    wi(solve(n, m, q, e))


def __starting_point():
    main()

__starting_point()