Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int,input().split()))
a = [aa-i-1 for i, aa in enumerate(a)]
answer = 100000000
for b in range(min(a), max(a)+1):
  res = 0
  for aa in a:
    res += abs(aa-b)
  answer = min(answer,res)
print(answer)

Fixed submission:
import math
import statistics
n = int(input())
a = list(map(int,input().split()))
a = [aa-i-1 for i, aa in enumerate(a)]
answer = n*10**20
median_low = statistics.median_low(a)
median_high = statistics.median_high(a)

for m in (median_low,median_high):
  ans=0
  for aa in a:
    ans += abs(aa-m)
  answer = min(ans,answer)
print(answer)
Buggy python submission (verdict: Time Limit Exceeded):
import sys

def solve(N: int, K: int, A: "List[int]"):
    # 最小値は絶対1になる
    cur = K
    answer = 1
    while K < N:
        cur+=K-1
        answer +=1
    print(answer)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, K, A)

if __name__ == '__main__':
    main()


Fixed submission:
N,K = (int(i) for i in input().split())
a = [int(x) for x in input().split()]

b= a.index(1)+1

if b/(K-1) == 0:
    answer = -(-(N-1)//(K-1)) +1

else:
    answer = -(-(N-1)//(K-1))

print(answer)
Buggy python submission (verdict: Runtime Error):
n = int(input())
suuretu = [int(x) for x in input().split()]
answer = 0
 
for i in suuretu:
    answer += calculate(i)
 
def calculate(i):
    a = 0
    while i % 2 == 0:
        i = i / 2
        a += 1
    return a

print(answer)

Fixed submission:
import math
n = int(input())
a = list(map(int,input().split()))
maxlog = int(math.log2(max(a)))
answer = 0
for _ in range(maxlog):
  a = [aa/2 for aa in a if aa%2==0]
  answer+= len(a)
  if not a:
    break
print(answer)

Buggy python submission (verdict: Runtime Error):
n = int(input())
suuretu = [int(x) for x in input().split()]
answer = 0
 
for i in suuretu:
    answer += calculate(i)
 
def calculate(i):
    a = 0
    while i % 2 == 0:
        i = i / 2
        a += 1
    return a

print(answer)

Fixed submission:
import math
n = int(input())
a = list(map(int,input().split()))
maxlog = int(math.log2(max(a)))
answer = 0
for _ in range(maxlog):
  a = [aa/2 for aa in a if aa%2==0]
  answer+= len(a)
  if not a:
    break
print(answer)

Buggy python submission (verdict: Runtime Error):
n = int(input())
suuretu = [int(x) for x in input().split()]
answer = 0

for i in suuretu:
    answer += calculate(i)

def calculate(i):
    a = 0
    while i % 2 == 0:
        i = i / 2
        a += 1

    return a


print(answer)

Fixed submission:
import math
n = int(input())
a = list(map(int,input().split()))
maxlog = int(math.log2(max(a)))
answer = 0
for _ in range(maxlog):
  a = [aa/2 for aa in a if aa%2==0]
  answer+= len(a)
  if not a:
    break
print(answer)

Buggy python submission (verdict: Runtime Error):
suuretu = [int(x) for x in input().split()]
answer = 0

for i in suuretu:
    answer += calculate(i)

def calculate(i):
    a = 0
    while i % 2 == 0:
        i = i / 2
        a += 1

    return a


print(answer)

Fixed submission:
import math
n = int(input())
a = list(map(int,input().split()))
maxlog = int(math.log2(max(a)))
answer = 0
for _ in range(maxlog):
  a = [aa/2 for aa in a if aa%2==0]
  answer+= len(a)
  if not a:
    break
print(answer)

Buggy python submission (verdict: Runtime Error):
suuretu = [int(x) for x in input().split()]
answer = 0

for i in suuretu:
    answer += calculate(i)


def calculate(int):
    a = 0
    while int % 2 == 0:
        int = int / 2
        a += 1
    
    return a 

print(answer)

Fixed submission:
import math
n = int(input())
a = list(map(int,input().split()))
maxlog = int(math.log2(max(a)))
answer = 0
for _ in range(maxlog):
  a = [aa/2 for aa in a if aa%2==0]
  answer+= len(a)
  if not a:
    break
print(answer)

Buggy python submission (verdict: Runtime Error):
suuretu = [int(x) for x in input().split()]
n = len(suuretu)
answer = 0

for i in suuretu:
    calculate(i)

def calculate(int):
    while int%2 == 0:
        int = int / 2
        answer += 1

print (answer)

Fixed submission:
import math
n = int(input())
a = list(map(int,input().split()))
maxlog = int(math.log2(max(a)))
answer = 0
for _ in range(maxlog):
  a = [aa/2 for aa in a if aa%2==0]
  answer+= len(a)
  if not a:
    break
print(answer)
Buggy python submission (verdict: Time Limit Exceeded):
n= int(input())
ninesix = [9**i for i in range(1,6) if 9**i <= n]+[6**i for i in range(1,7) if 6**i <= n]
ninesix.sort(reverse=True)

def coin(ns,max_res):
  if not ns:
    return max_res
  remainder = max_res//ns[0]
  if remainder > 0:
    count = 0
    c = 10000
    for i in range(1,remainder+1):
      nnss = ns[1:]
      c = min(coin(nnss,max_res-ns[0]*i)+i,c)
    count += c
    return count
  else:
    nnss = ns[1:]
    return coin(nnss,max_res)
  return count
   
print(coin(ninesix,n))
  

Fixed submission:
N=int(input())
ans=N
for i in range(N+1): 
    cnt=0
    t=i
    while t>0:
        cnt+=t%6
        t//=6
    s=N-i
    while s>0:
        cnt+=s%9
        s//=9
    ans=min(ans,cnt)
print(ans)

Buggy python submission (verdict: Runtime Error):
n= int(input())
ninesix = [9**i for i in range(1,6)]+[6**i for i in range(1,7)]
ninesix.sort(reverse=True)

def coin(ns,max_res):
  if max_res < 6:
    return max_res
  count = 0
  remainder = max_res//ns[0]
  c = 1000000000
  if remainder > 0:
    for i in range(1,remainder+1):
      nnss = ns[1:]
      c = min(coin(nnss,max_res-ns[0]*i),c)+i
    count += c
    return count
  else:
    return coin(ns[1:],max_res)
  return count
   
print(coin(ninesix,n))
  

Fixed submission:
N=int(input())
ans=N
for i in range(N+1): 
    cnt=0
    t=i
    while t>0:
        cnt+=t%6
        t//=6
    s=N-i
    while s>0:
        cnt+=s%9
        s//=9
    ans=min(ans,cnt)
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
#!/usr/bin/env python3
import sys
import itertools 

def solve(N: int, C: int, D: "List[List[int]]", c: "List[List[int]]"):
    c_list = list(itertools.permutations(range(C),3))
    answer = 10**9
    for zero,one,two in c_list:
        a = 0
        for i in range(N):
            for j  in range(N):
                color = c[i][j]
                if (i+j) % 3 == 0:
                    a+= D[color-1][zero]
                elif (i+j) % 3 == 1:
                    a+= D[color-1][one]
                elif (i+j) % 3 == 2:
                    a+= D[color-1][two]
        answer = min(answer,a)

    print(answer)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    D = [[int(next(tokens)) for _ in range(C)] for _ in range(C)]  # type: "List[List[int]]"
    c = [[int(next(tokens)) for _ in range(N)] for _ in range(N)]  # type: "List[List[int]]"
    solve(N, C, D, c)

if __name__ == '__main__':
    main()


Fixed submission:
#!/usr/bin/env python3
import sys
import itertools 

def solve(N: int, C: int, D: "List[List[int]]", c: "List[List[int]]"):
    answer = 10**9

    cost = [[0 for _ in range(C)] for _ in range(3)]


    for i in range(1,N+1):
        for j  in range(1,N+1):
            cost[(i+j)%3][c[i-1][j-1]-1] += 1

    for i in range(C):
        for j in range(C):
            for k in range(C):
                if i==j or j==k or k==i:
                    continue
                a = 0
                for index in range(C):
                    a += cost[0][index]*D[index][i]
                    a += cost[1][index]*D[index][j]
                    a += cost[2][index]*D[index][k]
                
                answer = min(a,answer)

    print(answer)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    D = [[int(next(tokens)) for _ in range(C)] for _ in range(C)]  # type: "List[List[int]]"
    c = [[int(next(tokens)) for _ in range(N)] for _ in range(N)]  # type: "List[List[int]]"
    solve(N, C, D, c)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
s = list(input())

answer = n
for i in range(0,n):
  answer= min(answer, s[:i].count('W')+s[i+1:].count('E'))
  
print(answer)

Fixed submission:
n = int(input())
s = list(input())
allwest = s.count("W")
alleast = n-allwest
left_west = 0
right_east = alleast if s[0] == "W" else alleast-1
answer = left_west + right_east
for i in range(1,n):
    left_west += 1 if s[i-1]=="W" else 0
    right_east -= 1 if s[i] == "E" else 0
    answer = min(answer,left_west+right_east)
print(answer)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
s = list(input())

answer = n
for i in range(0,n):
  answer= min(answer, s[:i].count('W')+s[i+1:].count('E'))
  
print(answer)

Fixed submission:
n = int(input())
s = list(input())
allwest = s.count("W")
alleast = n-allwest
left_west = 0
right_east = alleast if s[0] == "W" else alleast-1
answer = left_west + right_east
for i in range(1,n):
    left_west += 1 if s[i-1]=="W" else 0
    right_east -= 1 if s[i] == "E" else 0
    answer = min(answer,left_west+right_east)
print(answer)
Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python3
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(H: int, W: int, s: "List[str]"):
    s = ["."*(W+2)]+["."+ss+"."for ss in s]+["."*(W+2)]
    direction = ((0,1),(1,0),(0,-1),(-1,0))
    # 全ての黒マスの上下左右に一つでも黒マスがあればおk
    for i in range(H+2):
        for j in range(W+2):
            if s[i][j] == ".":
                continue
            
            for x,y in direction:
                if s[i+x][j+y] == "#":
                    break
            else:
                print(NO)
                return 
    
    print(YES)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    H = int(next(tokens))  # type: int
    W = int(next(tokens))  # type: int
    s = [next(tokens) for _ in range(W)]  # type: "List[str]"
    solve(H, W, s)

if __name__ == '__main__':
    main()


Fixed submission:
h,w = map(int,input().split())
cambus = [list(input()) for _ in range(h)]
import sys
for i in range(h):
  for j in range(w):
    if cambus[i][j]=="#":
      b = []
      if i != 0:
        b.append(cambus[i-1][j] == "#")
      if i != h-1:
        b.append(cambus[i+1][j] == "#")
      if j != 0:
        b.append(cambus[i][j-1] == "#")
      if j != w-1:
        b.append(cambus[i][j+1] == "#")

      if not any(b):
        print("No")
        sys.exit()

print("Yes")
Buggy python submission (verdict: Time Limit Exceeded):
import statistics
n = int(input())
x = list(map(int,input().split()))

for i in range(n):
  xx = x[:i] + x[i+1:]
  print(statistics.median(xx))
  

Fixed submission:
import statistics
n = int(input())
x = list(map(int,input().split()))

median_left = statistics.median_low(x)
median_right = statistics.median_high(x)

for i in range(n):
  if x[i] == median_right:
    print(median_left)
  elif x[i] == median_left:
    print(median_right)
  else:
    if x[i] < median_left:
      print(median_right)
    else:
      print(median_left)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int,input().split()))

for i in range(n):
  aa = a[:i]+a[i+1:]
  aa = [0]+aa+[0]
  print(sum([abs(aa[index+1]-aa[index]) for index in range(n)]))

Fixed submission:
n = int(input())
a = list(map(int,input().split()))
aa = [0]+a+[0]
allsum = sum([abs(aa[index+1]-aa[index]) for index in range(n+1)])

for i in range(1,n+1):  
  print(allsum-abs(aa[i]-aa[i-1])-abs(aa[i+1]-aa[i])+abs(aa[i+1]-aa[i-1]))
Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python3
import sys


def solve(A: int, B: int):
    # 100,100のグリッド作る
    grid = [["."]*100 for _ in range(50)]+ [["#"]*100 for _ in range(50)]
    A-=1
    B-=1

    # .を＃に置き換えていく
    for i in range(50):
        for j in range(100):
            if (i%2)^(j%2) == 1 and B > 0:
                grid[i][j] = "#"
                B-=1
    
    for i in range(51,100):
        for j in range(100):
            if (i%2)^(j%2) == 1 and A>0:
                grid[i][j] = "."
                A-=1
    
    print(100,100)
    for i in range(100):
        print(''.join(rid[i]))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)

if __name__ == '__main__':
    main()


Fixed submission:
#!/usr/bin/env python3
import sys


def solve(A: int, B: int):
    # 100,100のグリッド作る
    grid = [["."]*100 for _ in range(50)]+ [["#"]*100 for _ in range(50)]
    A-=1
    B-=1

    # .を＃に置き換えていく
    for i in range(50):
        for j in range(100):
            if i%2 == 0 and j%2 == 0 and B > 0:
                grid[i][j] = "#"
                B-=1
    
    for i in range(51,100):
        for j in range(100):
            if i%2 == 0 and j%2 == 0 and A>0:
                grid[i][j] = "."
                A-=1
    
    print(100, 100)
    for i in range(100):
        print(''.join(grid[i]))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(A, B)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
n = int(input())
red = [list(map(int,input().split())) for _ in range(n)]
blue = [list(map(int,input().split())) for _ in range(n)]
red_count = []
import copy

for i in range(n):
  index_list = []
  for j in range(n):
    if blue[j][0]>red[i][0] and blue[j][1]>red[i][1]:
      index_list.append(j)
  red_count.append(index_list)
red_count.sort(key=lambda x: len(x))

def redcounter(count,i,removed_index):
  if i == len(red_count)-1 and set(red_count[i])-set(removed_index):
    return count+1
  elif  i == len(red_count)-1: 
    return count
  
  if red_count[i]:
    for index in range(len(red_count[i])): ## removeするindex
      if red_count[i][index] not in removed_index:
        removed_index_copy = copy.copy(removed_index)
        c = count
        removed_index_copy.append(red_count[i][index])
        c = max(c,redcounter(count,i+1,removed_index_copy))
    return c+1
  else:
    return redcounter(count,i+1,removed_index)
   
print(redcounter(0,0,[]))
  


    

Fixed submission:
n = int(input())
lired = [list(map(int,input().split())) for _ in range(n)]
liblue = [list(map(int,input().split())) for _ in range(n)]
lired = sorted(lired,key = lambda x:-x[1])
liblue = sorted(liblue,key = lambda x:x[0])
li = list(range(n))
count = 0

for i in range(n):
  for j in li:
    if lired[i][0] < liblue[j][0] and lired[i][1] < liblue[j][1]:
      count += 1
      li.remove(j)
      break
print(count)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
red = [list(map(int,input().split())) for _ in range(n)]
blue = [list(map(int,input().split())) for _ in range(n)]
red_count = []
import copy

for i in range(n):
  index_list = []
  for j in range(n):
    if blue[j][0]>red[i][0] and blue[j][1]>red[i][1]:
      index_list.append(j)
  red_count.append(index_list)
red_count.sort(key=lambda x: len(x))

def redcounter(count,i,red_count):
  if i == len(red_count)-1 and red_count[i]:
    return count+1
  elif  i == len(red_count)-1:
    return count
  
  if red_count[i]:
    for index in range(len(red_count[i])): ## removeするindex
      remove_index = red_count[i][index]
      red_count_copy = copy.deepcopy(red_count)
      c = count
      for j in range(i+1,len(red_count_copy)): ## removeしていく
        if remove_index in red_count_copy[j]:
          red_count_copy[j].remove(remove_index)
      c = max(count,redcounter(c,i+1,red_count_copy))
    return c+1
  else:
    return redcounter(count,i+1,red_count)
   
print(redcounter(0,0,red_count))
  


    

Fixed submission:
n = int(input())
lired = [list(map(int,input().split())) for _ in range(n)]
liblue = [list(map(int,input().split())) for _ in range(n)]
lired = sorted(lired,key = lambda x:-x[1])
liblue = sorted(liblue,key = lambda x:x[0])
li = list(range(n))
count = 0

for i in range(n):
  for j in li:
    if lired[i][0] < liblue[j][0] and lired[i][1] < liblue[j][1]:
      count += 1
      li.remove(j)
      break
print(count)
Buggy python submission (verdict: Time Limit Exceeded):
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)

def maxValue(z:int, w:int, a:"List[int]", player:str) -> int:
    if not a:
        return abs(z-w)

    if player == "X": ## playerXが操作する。価値がmaxになるように
        value = 0
        for i in range(len(a)):
            value = max(maxValue(a[i],w,a[i+1:],"Y"),value)
    else: ## yが操作,価値がminになるように
        value = 10**9
        for i in range(len(a)):
            value = min(maxValue(z,a[i],a[i+1:],"X"),value)
    return value        

def solve(N: int, Z: int, W: int, a: "List[int]"):
    print(maxValue(Z,W,a,"X"))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    Z = int(next(tokens))  # type: int
    W = int(next(tokens))  # type: int
    a = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, Z, W, a)

if __name__ == '__main__':
    main()


Fixed submission:
#!/usr/bin/env python3
import sys

def solve(N: int, Z: int, W: int, a: "List[int]"):
    print(max(abs(a[N-1]-a[N-2]),abs(a[N-1]-W)))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    Z = int(next(tokens))  # type: int
    W = int(next(tokens))  # type: int
    a = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, Z, W, a)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):
#!/usr/bin/env python3
import sys
import itertools

def solve(N: int, K: int, x: "List[int]", y: "List[int]"):
    answer = 10**19

    x_set = sorted(list(set(x)))
    y_set = sorted(list(set(y)))
    x_combination = list(itertools.combinations(x_set,2))
    y_combination = list(itertools.combinations(y_set,2))

    
    for x_l, x_u in x_combination:
        for y_l, y_u in y_combination:
            count = 0
            for i in range(N):
                if y_l <= y[i] <= y_u and x_l <= x[i] <= x_u:
                    count +=1
            if count >= K:
                answer = min(answer,(y_u-y_l)*(x_u-x_l))

    print(answer)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    x = [int()] * (N)  # type: "List[int]"
    y = [int()] * (N)  # type: "List[int]"
    for i in range(N):
        x[i] = int(next(tokens))
        y[i] = int(next(tokens))
    solve(N, K, x, y)

if __name__ == '__main__':
    main()


Fixed submission:
#!/usr/bin/env python3
import sys
import itertools

def solve(N: int, K: int, x: "List[int]", y: "List[int]"):
    answer = 10**19

    x_set = sorted(list(set(x)))
    y_set = sorted(list(set(y)))
    x_combination = list(itertools.combinations(x_set,2))
    y_combination = list(itertools.combinations(y_set,2))

    
    for x_l, x_u in x_combination:
        for y_l, y_u in y_combination:
            count = 0
            for i in range(N):
                if y_l <= y[i] <= y_u and x_l <= x[i] <= x_u:
                    count +=1
            if count >= K:
                answer = min(answer,(y_u-y_l)*(x_u-x_l))

    print(answer)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    x = [int()] * (N)  # type: "List[int]"
    y = [int()] * (N)  # type: "List[int]"
    for i in range(N):
        x[i] = int(next(tokens))
        y[i] = int(next(tokens))
    solve(N, K, x, y)

if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
#!/usr/bin/env python3
import sys

YES = "POSSIBLE"  # type: str
NO = "IMPOSSIBLE"  # type: str


def solve(N: int, K: int, A: "List[int]"):
    if K in A:
        print(YES)
        return
    
    if max(A) < K:
        print(NO)
        return
    
    ## 互いに素のものが一つでもあれば1が作れるからなんでも作れる→互いにそのものがあるか判定
    from math import fractions
    from functools import reduce
    def gcd_list(numbers):
        return reduce(fractions.gcd, numbers)
    
    if gcd_list(A) == 1:
        print(YES)
    else:
        if K%gcd_list(A) == 0:
            print(YES)
        else:
            print(NO)

    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, K, A)

if __name__ == '__main__':
    main()


Fixed submission:
#!/usr/bin/env python3
import sys

YES = "POSSIBLE"  # type: str
NO = "IMPOSSIBLE"  # type: str

def solve(N: int, K: int, A: "List[int]"):
    if K in A:
        print(YES)
        return
    
    if max(A) < K:
        print(NO)
        return
    
    ## 互いに素のものが一つでもあれば1が作れるからなんでも作れる→互いにそのものがあるか判定
    import fractions
    from functools import reduce
    def gcd_list(numbers):
        return reduce(fractions.gcd, numbers)
    
    if gcd_list(A) == 1:
        print(YES)
    else:
        if K%gcd_list(A) == 0:
            print(YES)
        else:
            print(NO)

    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    K = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, K, A)

if __name__ == '__main__':
    main()