Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
N, M = input().split(" ")
N = int(N)
M = int(M)
s_list = []
c_list = []
for i in range(M):
    si, ci = input().split(" ")
    s_list.append(int(si))
    c_list.append(int(ci))
num = ["0" for i in range(N)]
for si, ci in zip(s_list, c_list):
    if num[si-1] != "0" and num[si-1] != str(ci):
        print(-1)
        is_break = True
        break
    elif N > 1 and si == 1 and ci == 0:
        print(-1)
        is_break = True
        break
    else:
        num[si-1] = str(ci)
if not is_break:
    num = int("".join([val for val in num]))
    if num:
        print(num)
    else:
        print(0)

Fixed submission:
N, M = input().split(" ")
N = int(N)
M = int(M)
s_list = []
c_list = []
for i in range(M):
    si, ci = input().split(" ")
    s_list.append(int(si))
    c_list.append(int(ci))
num = ["0" for i in range(N)]
is_break = False
for si, ci in zip(s_list, c_list):
    if num[si-1] != "0" and num[si-1] != str(ci):
        print(-1)
        is_break = True
        break
    elif N > 1 and si == 1 and ci == 0:
        print(-1)
        is_break = True
        break
    else:
        num[si-1] = str(ci)
if not is_break:
    num = "".join([val for val in num])
    if int(num[0]) or N == 1:
        print(int(num))
    else:
        print(int("1" + num[1:]))

Buggy python submission (verdict: Runtime Error):
N, M = input().split(" ")
N = int(N)
M = int(M)
s_list = []
c_list = []
for i in range(M):
    si, ci = input().split(" ")
    s_list.append(int(si))
    c_list.append(int(ci))

num = ["0" for i in range(N)]
is_num = [0 for i in range(N)]
is_break = False
for si, ci in zip(s_list, c_list):
    if num[si-1] != "0" and num[si-1] != str(ci):
        print(-1)
        is_break = True
        break
    else:
        num[si-1] = str(ci)
        num[si-1] = 1
if not is_break:
    num = int("".join([val for val in num]))
    if num:
        print(num)
    elif is_num[-1] == 0:
        print(1)
    else:
        print(0)

Fixed submission:
N, M = input().split(" ")
N = int(N)
M = int(M)
s_list = []
c_list = []
for i in range(M):
    si, ci = input().split(" ")
    s_list.append(int(si))
    c_list.append(int(ci))
num = ["0" for i in range(N)]
is_break = False
for si, ci in zip(s_list, c_list):
    if num[si-1] != "0" and num[si-1] != str(ci):
        print(-1)
        is_break = True
        break
    elif N > 1 and si == 1 and ci == 0:
        print(-1)
        is_break = True
        break
    else:
        num[si-1] = str(ci)
if not is_break:
    num = "".join([val for val in num])
    if int(num[0]) or N == 1:
        print(int(num))
    else:
        print(int("1" + num[1:]))
Buggy python submission (verdict: Runtime Error):
import numpy as np

N = int(input())
A = np.array([int(val) for val in A])

A_even = set(A[A%2==0])
A_three = set(A[A%3==0])
A_five = set(A[A%5==0])

A_approve = A_even & (A_three | A_five)

if A_even == A_approve:
    print('APPROVED')
else:
    print('DENIED')

Fixed submission:
import numpy as np
 
N = int(input())
A = input().split()
A = np.array([int(val) for val in A])
 
A_even = set(A[A%2==0])
A_three = set(A[A%3==0])
A_five = set(A[A%5==0])
 
A_approve = A_even & (A_three | A_five)
 
if A_even == A_approve:
    print('APPROVED')
else:
    print('DENIED')
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
S_list = []
for _ in range(N):
    S_list.append(input())

str_list = set(S_list)
str_count_dict = {}
for val in str_list:
    str_count_dict[val] = S_list.count(val)

max_key = sorted([key for key, val in str_count_dict.items()\
                  if val == max(str_count_dict.values())])

print('\n'.join(max_key))

Fixed submission:
N = int(input())
S_list = [input() for i in range(N)]
 
S_count = {}
for Si in S_list:
    if Si in S_count:
        S_count[Si] += 1
    else:
        S_count[Si] = 1

S_max = max(S_count.values())
S_count_sorted = sorted([key for key, val in S_count.items()\
                  if val == S_max])
 
print('\n'.join(S_count_sorted))
Buggy python submission (verdict: Runtime Error):
from collections import deque


def dfs(maze, start):
    move = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    q = deque([0, start])
    dist = [[-1] * w for _ in range(h)]

    depth, i, j = -1, -1, -1

    while q:
        depth, (i, j) = q.popleft()
        if dist[i][j] != -1:
            continue
        dist[i][j] = depth
        for di, dj in move:
            ni, nj = i + di, j + dj

            outside = not 0 <= ni < h or not 0 <= nj < w
            is_wall = maze[ni][nj] == "#"
            visited = dist[ni][nj] != -1

            if outside or is_wall or visited:
                continue

            q.append((depth + 1, (ni, nj)))

    return depth, i, j


h, w = list(map(int, input().split()))

maze = []

for _ in range(h):
    maze.append(input())

answer = 0

for i in range(h):
    for j in range(w):
        if maze[i][j] == ".":
            depth, i, j = dfs(maze, (i, j))
            answer = max(answer, depth)

print(answer)

Fixed submission:
from collections import deque


def dfs(maze, start):
    move = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    q = deque([(0, start)])
    dist = [[-1] * w for _ in range(h)]

    depth, i, j = -1, -1, -1

    while q:
        depth, (i, j) = q.popleft()
        if dist[i][j] != -1:
            continue
        dist[i][j] = depth
        for di, dj in move:
            ni, nj = i + di, j + dj

            if (not 0 <= ni < h) or (not 0 <= nj < w):
                continue

            if maze[ni][nj] == "#" or dist[ni][nj] != -1:
                continue

            q.append((depth + 1, (ni, nj)))

    return depth, i, j


h, w = list(map(int, input().split()))

maze = []

for _ in range(h):
    maze.append(input())

answer = 0

for i in range(h):
    for j in range(w):
        if maze[i][j] == ".":
            depth, i, j = dfs(maze, (i, j))
            answer = max(answer, depth)

print(answer)
Buggy python submission (verdict: Runtime Error):
# from scipy.special import comb

from math import factorial

MOD = 10 ** 9 + 7
x, y = map(int, input().split())

if (x + y) % 3 != 0:
    print(0)
else:
    # (+1, +2) n
    # (+2, +1) m
    # n + 2m = x
    # 2n + m = y
    m = (2 * x - y) // 3
    n = (2 * y - x) // 3
    score = factorial(n + m) // factorial(n) // factorial(m)
    # score = comb(n + m, n, exact=True)
    print(score % MOD)

Fixed submission:
# from scipy.special import comb
# from math import factorial
# from operator import mul
# from functools import reduce

# def combination(n, r):
#     r = min(n - r, r)
#     if r == 0:
#         return 1
#     over = reduce(mul, range(n, n - r, -1))
#     under = reduce(mul, range(1, r + 1))
#     return over // under


def combination(n, r, mod=10 ** 9 + 7):
    n1, r = n + 1, min(r, n - r)
    numerator = denominator = 1
    for i in range(1, r + 1):
        numerator = numerator * (n1 - i) % mod
        denominator = denominator * i % mod

    return numerator * pow(denominator, mod - 2, mod) % mod


x, y = map(int, input().split())

if (x + y) % 3 != 0 or (x > 2 * y or y > 2 * x):
    print(0)
else:
    # (+1, +2) n
    # (+2, +1) m
    # n + 2m = x
    # 2n + m = y
    m = (2 * x - y) // 3
    n = (2 * y - x) // 3
    # score = factorial(n + m) // factorial(n) // factorial(m)
    # score = comb(n + m, n, exact=True)
    score = combination(n + m, n)
    print(score)
Buggy python submission (verdict: Time Limit Exceeded):
from collections import defaultdict

n, t = map(int, input().split())
menu = []

for _ in range(n):
    a, b = map(int, input().split())
    menu.append((a, b))

menu = sorted(menu)

dp = defaultdict(int)
dp[0] = 0

score = 0

for a, b in menu:
    for time, utility in list(dp.items()):
        if time + a >= t:
            score = max(score, utility + b)
        else:
            dp[time + a] = max(dp[time + a], utility + b)

print(max(score, max(dp.values())))

Fixed submission:
from collections import defaultdict

n, t = map(int, input().split())
menu = []

for _ in range(n):
    a, b = map(int, input().split())
    menu.append((a, b))

menu = sorted(menu)

dp = defaultdict(int)
dp[0] = 0

score = 0

for a, b in menu:
    for time, utility in list(dp.items()):
        if time + a >= t:
            score = max(score, utility + b)
        else:
            dp[time + a] = max(dp[time + a], utility + b)

print(max(score, max(dp.values())))
Buggy python submission (verdict: Runtime Error):
import math

a, b, x = list(map(int, input().split()))

x /= a  # focus on the rectangle a * b

if a * b / 2 > x:
    c = 2 * x / b
    answer = math.degrees(math.atan2(b / c))
    print(answer)
else:
    rest = a * b - x
    c = 2 * rest / a
    answer = math.degrees(math.atan2(c / a))
    print(answer)

Fixed submission:
import math

a, b, x = list(map(int, input().split()))

x /= a  # focus on the rectangle a * b

if a * b / 2 > x:
    c = 2 * x / b
    answer = math.degrees(math.atan(b / c))
    print(answer)
else:
    rest = a * b - x
    c = 2 * rest / a
    answer = math.degrees(math.atan(c / a))
    print(answer)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
s = input()

compressed = s[0]
for i in range(1, n):
    if s[i] != s[i - 1]:
        compressed += s[i]

print(len(compressed))

Fixed submission:
n = int(input())
s = input()

compressed = s[0]
for i in range(1, n):
    if s[i] != s[i - 1]:
        compressed += s[i]

print(len(compressed))
Buggy python submission (verdict: Time Limit Exceeded):
from itertools import combinations

n = int(input())
ls = list(map(int, input().split()))
ls.sort()

count = 0
# for a, b, c in combinations(ls, 3):
#     if a < b + c and b < c + a and c < a + b:
#         count += 1
for j in range(n - 1, 1, -1):
    last = ls[j]
    for a, b in combinations(ls[:j], 2):
        if a + b > last:
            count += 1

print(count)

Fixed submission:
# from itertools import combinations
from bisect import bisect_left

n = int(input())
ls = list(map(int, input().split()))
ls.sort()

count = 0

# for a, b, c in combinations(ls, 3):
#     if a < b + c and b < c + a and c < a + b:
#         count += 1

# for j in range(n - 1, 1, -1):
#     last = ls[j]
#     for a, b in combinations(ls[:j], 2):
#         if a + b > last:
#             count += 1

for i in range(n - 1, 1, -1):
    for j in range(i - 1, 0, -1):
        idx = bisect_left(ls[:j], ls[i] - ls[j] + 1)
        if idx < j:
            count += j - idx

print(count)

Buggy python submission (verdict: Time Limit Exceeded):
from itertools import combinations

n = int(input())
ls = list(map(int, input().split()))
ls.sort()

count = 0
# for a, b, c in combinations(ls, 3):
#     if a < b + c and b < c + a and c < a + b:
#         count += 1
for j in range(n - 1, 1, -1):
    last = ls[j]
    for a, b in combinations(ls[:j], 2):
        if a + b > last:
            count += 1

print(count)

Fixed submission:
# from itertools import combinations
from bisect import bisect_left

n = int(input())
ls = list(map(int, input().split()))
ls.sort()

count = 0

# for a, b, c in combinations(ls, 3):
#     if a < b + c and b < c + a and c < a + b:
#         count += 1

# for j in range(n - 1, 1, -1):
#     last = ls[j]
#     for a, b in combinations(ls[:j], 2):
#         if a + b > last:
#             count += 1

for i in range(n - 1, 1, -1):
    for j in range(i - 1, 0, -1):
        idx = bisect_left(ls[:j], ls[i] - ls[j] + 1)
        if idx < j:
            count += j - idx

print(count)

Buggy python submission (verdict: Time Limit Exceeded):
from itertools import combinations

n = int(input())
ls = list(map(int, input().split()))

count = 0
for a, b, c in combinations(ls, 3):
    if a < b + c and b < c + a and c < a + b:
        count += 1

print(count)

Fixed submission:
# from itertools import combinations
from bisect import bisect_left

n = int(input())
ls = list(map(int, input().split()))
ls.sort()

count = 0

# for a, b, c in combinations(ls, 3):
#     if a < b + c and b < c + a and c < a + b:
#         count += 1

# for j in range(n - 1, 1, -1):
#     last = ls[j]
#     for a, b in combinations(ls[:j], 2):
#         if a + b > last:
#             count += 1

for i in range(n - 1, 1, -1):
    for j in range(i - 1, 0, -1):
        idx = bisect_left(ls[:j], ls[i] - ls[j] + 1)
        if idx < j:
            count += j - idx

print(count)
Buggy python submission (verdict: Time Limit Exceeded):
from collections import Counter
from copy import deepcopy

n = int(input())
a = list(map(int, input().split()))
c = Counter(a)

for k in range(1, n + 1):
    cx = deepcopy(c)

    count = 0

    while k <= len(cx):
        # print(cx)
        mc = cx.most_common()
        for key, _ in mc[:k]:
            cx[key] -= 1
            if cx[key] < 1:
                del cx[key]
        count += 1

    print(count)


Fixed submission:
from collections import Counter
from itertools import accumulate

# from copy import deepcopy

n = int(input())
a = list(map(int, input().split()))
c = Counter(a)

# for k in range(1, n + 1):
#     cx = deepcopy(c)

#     count = 0

#     while k <= len(cx):
#         # print(cx)
#         mc = cx.most_common()
#         for key, _ in mc[:k]:
#             cx[key] -= 1
#             if cx[key] < 1:
#                 del cx[key]
#         count += 1

#     print(count)

cv = Counter(c.values())
max_take = max(cv.keys())

lx = list(accumulate(cv[i] for i in range(max_take + 1)))
rx = list(accumulate(cv[i] * i for i in range(max_take + 1)))
ax = [rx[i] + (lx[-1] - lx[i]) * i for i in range(max_take + 1)]


def bisec(l0, r0, predicate):
    l, r = l0, r0

    while abs(l - r) > 1:
        mid = (l + r) // 2
        if predicate(mid):
            r = mid
        else:
            l = mid

    return r


for k in range(1, n + 1):
    print(bisec(n + 1, 0, lambda x: x * k <= ax[min(x, max_take)]))
Buggy python submission (verdict: Time Limit Exceeded):
a, b = list(map(int, input().split()))

cands = set()

for i in range(2, min(a, b) + 1):
    if a % i != 0 or b % i != 0:
        continue
    if not any([i % x == 0 for x in cands]):
        cands.add(i)

print(len(cands) + 1)

Fixed submission:
a, b = list(map(int, input().split()))


def prime_factorize(n):
    """Return the prime factorization of n > 1.
    >>> prime_factorize(36)
    [2, 2, 3, 3]
    """
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2

    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2

    if n != 1:
        a.append(n)

    return a


def main(a, b):
    pf_a = set(prime_factorize(a))
    pf_b = set(prime_factorize(b))
    return len(pf_a & pf_b) + 1


print(main(a, b))

Buggy python submission (verdict: Time Limit Exceeded):
a, b = list(map(int, input().split()))


def comdiv(n, m):
    cds = []  # exclude 1
    for i in range(2, min(n, m) + 1):
        if n % i == 0 and m % i == 0:
            cds.append(i)

    return sorted(cds)


def main(a, b):
    cds = comdiv(a, b)
    cand = set()

    for cd in cds:
        if len(cand) == 0:
            cand.add(cd)
            continue
        if all([cd % x != 0 for x in cand]):
            cand.add(cd)

    return len(cand) + 1


print(main(a, b))

Fixed submission:
a, b = list(map(int, input().split()))


def prime_factorize(n):
    """Return the prime factorization of n > 1.
    >>> prime_factorize(36)
    [2, 2, 3, 3]
    """
    a = []
    while n % 2 == 0:
        a.append(2)
        n //= 2

    f = 3
    while f * f <= n:
        if n % f == 0:
            a.append(f)
            n //= f
        else:
            f += 2

    if n != 1:
        a.append(n)

    return a


def main(a, b):
    pf_a = set(prime_factorize(a))
    pf_b = set(prime_factorize(b))
    return len(pf_a & pf_b) + 1


print(main(a, b))
Buggy python submission (verdict: Time Limit Exceeded):
n, m = map(int, input().split())
prices = []
keymap = []
for _ in range(m):
    a, b = map(int, input().split())
    prices.append(a)
    c = list(map(int, input().split()))
    state = 0
    for ck in c:
        state |= 1 << ck - 1
        # print(format(state, "b"))
    keymap.append(state)

# print(keymap)

dp = [float("inf")] * (1 << n)  # 2 ** n
dp[0] = 0

for price, keyto in zip(prices, keymap):
    # print("--- step start ---")
    # print(dp)
    dp_new = dp[:]
    for s, d in enumerate(dp):
        # print("=== DP ===")
        # print("s:", format(s, "b"))
        # print("c:", format(keyto, "b"))
        dp_new[s | keyto] = min(d + price, dp_new[s | keyto])

    dp = dp_new
    # print(dp)

cost = dp[-1]
print(cost if cost != float("inf") else -1)

Fixed submission:
n, m = map(int, input().split())
prices = []
keymap = []
for _ in range(m):
    a, b = map(int, input().split())
    prices.append(a)
    c = list(map(int, input().split()))
    state = 0
    for ck in c:
        state |= 1 << ck - 1
        # print(format(state, "b"))
    keymap.append(state)

# print(keymap)

dp = [float("inf")] * (1 << n)  # 2 ** n
dp[0] = 0

for price, keyto in zip(prices, keymap):
    # print("--- step start ---")
    # print(dp)
    dp_new = dp[:]
    for s, d in enumerate(dp):
        # print("=== DP ===")
        # print("s:", format(s, "b"))
        # print("c:", format(keyto, "b"))
        dp_new[s | keyto] = min(d + price, dp_new[s | keyto])

    dp = dp_new
    # print(dp)

cost = dp[-1]
print(cost if cost != float("inf") else -1)
Buggy python submission (verdict: Runtime Error):
def main():
    n, x = list(map(int, input().split()))
    ls = list(map(int, input().split()))

    count = 1
    d = 0
    for i in range(n + 1):
        d = d + ls[i]
        if d > x:
            break
        else:
            count += 1

    print(count)


main()

Fixed submission:
def main():
    n, x = list(map(int, input().split()))
    ls = list(map(int, input().split()))

    count = 1
    d = 0
    for i in range(n):
        d = d + ls[i]
        if d > x:
            break
        else:
            count += 1

    print(count)


main()
Buggy python submission (verdict: Time Limit Exceeded):
def main():
    h, w = list(map(int, input().split()))
    grid = []
    for _ in range(h):
        grid.append(input())

    L = [[0 for _ in range(w)] for _ in range(h)]
    R = [[0 for _ in range(w)] for _ in range(h)]
    D = [[0 for _ in range(w)] for _ in range(h)]
    U = [[0 for _ in range(w)] for _ in range(h)]

    for i in range(h):
        for j in range(w):
            if grid[i][j] == '#':
                continue
            if j == 0:
                L[i][j] = 1
            else:
                L[i][j] = L[i][j - 1] + 1

    for i in range(h):
        for j in range(w - 1, -1, -1):
            if grid[i][j] == '#':
                continue
            if j == w - 1:
                R[i][j] = 1
            else:
                R[i][j] = R[i][j + 1] + 1

    for j in range(w):
        for i in range(h):
            if grid[i][j] == '#':
                continue
            if i == 0:
                D[i][j] = 1
            else:
                D[i][j] = D[i - 1][j] + 1

    for j in range(w):
        for i in range(h - 1, -1, -1):
            if grid[i][j] == '#':
                continue
            if i == h - 1:
                U[i][j] = 1
            else:
                U[i][j] = U[i + 1][j] + 1

    score = 0
    for i in range(h):
        for j in range(w):
            score = max(score, L[i][j] + R[i][j] + D[i][j] + U[i][j] - 3)

    print(score)


main()

Fixed submission:
import numpy as np


def main():
    h, w = list(map(int, input().split()))
    grid = []
    for _ in range(h):
        grid.append(list(input()))

    grid = np.array(grid) == '.'
    # print(grid)

    L = np.zeros((h, w), dtype=int)
    R = np.zeros((h, w), dtype=int)
    D = np.zeros((h, w), dtype=int)
    U = np.zeros((h, w), dtype=int)

    for i in range(1, h):
        U[i] = (U[i - 1] + 1) * grid[i - 1]
        # print(U[i])
    # print(U)

    for i in reversed(range(h - 1)):
        D[i] = (D[i + 1] + 1) * grid[i + 1]

    for j in range(1, w):
        L[:, j] = (L[:, j - 1] + 1) * grid[:, j - 1]
        # print(L[:, j])
    # print(L)

    for j in reversed(range(w - 1)):
        R[:, j] = (R[:, j + 1] + 1) * grid[:, j + 1]

    score = ((U + D + L + R) * grid).max() + 1
    print(score)


main()
Buggy python submission (verdict: Time Limit Exceeded):
from operator import itemgetter


def main():
    n, q = list(map(int, input().split()))
    stops = []
    for _ in range(n):
        s, t, x = list(map(int, input().split()))
        stops.append((s, t, x))
    delay = []
    for i in range(q):
        delay.append([int(input()), False, -1])

    stops = sorted(stops, key=itemgetter(2))

    for s, t, x in stops:
        for idx, item in enumerate(delay):
            d, stopped, score = item
            if not stopped:
                time_at_x = x + d
                if s - 0.5 < time_at_x < t - 0.5:
                    delay[idx][2] = x
                    delay[idx][1] = True

    for item in delay:
        print(item[2])


main()

Fixed submission:
from operator import itemgetter
from bisect import bisect_left


def main():
    n, q = list(map(int, input().split()))
    stops = []
    for _ in range(n):
        s, t, x = list(map(int, input().split()))
        stops.append((s, t, x))
    delay = []
    for i in range(q):
        delay.append(int(input()))

    stops = sorted(stops, key=itemgetter(2))
    delay = sorted(delay)

    result = [-1] * q
    skips = [-1] * q

    for s, t, x in stops:
        sx = bisect_left(delay, s - x)
        tx = bisect_left(delay, t - x)
        while sx < tx:
            if skips[sx] == -1:
                result[sx] = x
                skips[sx] = tx
                sx += 1
            else:
                sx = skips[sx]

    for r in result:
        print(r)


main()
Buggy python submission (verdict: Time Limit Exceeded):
# from time import perf_counter


def main():
    r, g, b, n = list(map(int, input().split()))
    count = 0
    x1, x2, x3 = sorted([r, g, b], reverse=True)
    # print(x1, x2, x3)
    for i in range(n // x1 + 1):
        for j in range((n - i) // x2 + 1):
            for k in range((n - i - j) // x3 + 1):
                # print(f'{r}*{i} + {g}*{j} + {b}*{k} = {r*i+g*j+k+b*k}')
                if x1 * i + x2 * j + x3 * k == n:
                    count += 1

    print(count)


if __name__ == '__main__':
    # s = perf_counter()
    main()
    # e = perf_counter()
    # print('process:', e - s)


Fixed submission:
# from time import perf_counter


def main():
    r, g, b, n = list(map(int, input().split()))
    count = 0
    x1, x2, x3 = sorted([r, g, b], reverse=True)
    # print(x1, x2, x3)
    for i in range(n // x1 + 1):
        for j in range((n - i) // x2 + 1):
            rest = n - (x1 * i) - (x2 * j)
            # print(f'{x1}*{i} + {x2}*{j} = {n - rest}')
            if rest == 0:
                # print(f'{x1}*{i} + {x2}*{j} + {x3}*0 = {n}')
                count += 1
            else:
                # print(f'{x1}*{i} + {x2}*{j} + {x3}*? = {n}')
                count += (1 if rest > 0 and rest % x3 == 0 else 0)
            # for k in range((n - i - j) // x3 + 1):
                # print(f'{r}*{i} + {g}*{j} + {b}*{k} = {r*i+g*j+k+b*k}')
            #    if x1 * i + x2 * j + x3 * k == n:
            #        count += 1

    print(count)


if __name__ == '__main__':
    # s = perf_counter()
    main()
    # e = perf_counter()
    # print('process:', e - s)