TnT/CodeNet4Repair huggingface dataset:
Problem:
There are two standard ways to represent a graph $G = (V, E)$, where $V$ is a set of vertices and $E$ is a set of edges; Adjacency list representation and Adjacency matrix representation.  An adjacency-list representation consists of an array $Adj[|V|]$ of $|V|$ lists, one for each vertex in $V$. For each $u \in V$, the adjacency list $Adj[u]$ contains all vertices $v$ such that there is an edge $(u, v) \in E$. That is, $Adj[u]$ consists of all vertices adjacent to $u$ in $G$.  An adjacency-matrix representation consists of $|V| \times |V|$ matrix $A = a_{ij}$ such that $a_{ij} = 1$ if $(i, j) \in E$, $a_{ij} = 0$ otherwise.  Write a program which reads a directed graph $G$ represented by the adjacency list, and prints its adjacency-matrix representation. $G$ consists of $n\; (=|V|)$ vertices identified by their IDs $1, 2,.., n$ respectively.

Incorrect submission (verdict: Wrong Answer):
n = int(input())
GM = [[0]*n for i in range(n)]

for i in range(n):
    data = list(map(int,input().split()))
    for i in range(data[1]):
        GM[data[0]-1][data[i+2]-1] = 1

    print(*GM[i])

Fixed, accepted submission:
n = int(input())
GM = [[0]*n for i in range(n)]

for i in range(n):
    data = list(map(int,input().split()))
    for i in range(data[1]):
        GM[data[0]-1][data[i+2]-1] = 1


for i in range(n):
    print(*GM[i])
Problem:
There are N children in AtCoder Kindergarten. Mr. Evi will arrange the children in a line, then give 1 candy to the first child in the line, 2 candies to the second child, ..., N candies to the N-th child. How many candies will be necessary in total?

Incorrect submission (verdict: Wrong Answer):
N = int(input())
print((1+N) * N/2)


Fixed, accepted submission:
N = int(input())
print(int((1+N) * N/2))
Problem:
A railroad running from west to east in Atcoder Kingdom is now complete.  There are N stations on the railroad, numbered 1 through N from west to east.  Tomorrow, the opening ceremony of the railroad will take place.  On this railroad, for each integer i such that 1≤i≤N-1, there will be trains that run from Station i to Station i+1 in C_i seconds. No other trains will be operated.  The first train from Station i to Station i+1 will depart Station i S_i seconds after the ceremony begins. Thereafter, there will be a train that departs Station i every F_i seconds.  Here, it is guaranteed that F_i divides S_i.  That is, for each Time t satisfying S_i≤t and t％F_i=0, there will be a train that departs Station i t seconds after the ceremony begins and arrives at Station i+1 t+C_i seconds after the ceremony begins, where A％B denotes A modulo B, and there will be no other trains.  For each i, find the earliest possible time we can reach Station N if we are at Station i when the ceremony begins, ignoring the time needed to change trains.

Incorrect submission (verdict: Wrong Answer):
n = int(input())
c = [0]*(n-1)
s = [0]*(n-1)
f = [0]*(n-1)

for i in range(n-1):
    c[i],s[i],f[i] = map(int,input().split())
for i in range(n-1):
    t = 0
    for j in range(i,n-1):
        if(t<s[j]):
            t = s[j]
        elif(t%f[j]):
            t += f[j]-(t%f[j])
        t += c[j]
    print(t)

Fixed, accepted submission:
n = int(input())
c = [0]*(n-1)
s = [0]*(n-1)
f = [0]*(n-1)

for i in range(n-1):
    c[i],s[i],f[i] = map(int,input().split())
for i in range(n):
    t = 0
    for j in range(i,n-1):
        if(t<s[j]):
            t = s[j]
        elif(t%f[j]):
            t += f[j]-(t%f[j])
        t += c[j]
    print(t)
Problem:
There are N rectangular plate materials made of special metal called AtCoder Alloy. The dimensions of the i-th material are A_i \times B_i (A_i vertically and B_i horizontally).  Takahashi wants a rectangular plate made of AtCoder Alloy whose dimensions are exactly H \times W. He is trying to obtain such a plate by choosing one of the N materials and cutting it if necessary. When cutting a material, the cuts must be parallel to one of the sides of the material. Also, the materials have fixed directions and cannot be rotated. For example, a 5 \times 3 material cannot be used as a 3 \times 5 plate.  Out of the N materials, how many can produce an H \times W plate if properly cut?

Incorrect submission (verdict: Wrong Answer):
n,h,w=map(int,input().split())
ans=0
for i in range(n):
  a,b=map(int,input().split())
  if a<=h and b<=w:
    ans+=1
print(ans)

Fixed, accepted submission:
import sys
readline = sys.stdin.readline

N,H,W = map(int,readline().split())
ans = 0
for i in range(N):
  a,b = map(int,readline().split())
  if a >= H and b >= W:
    ans += 1
print(ans)
Problem:
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.

Incorrect submission (verdict: Wrong Answer):
import math


def main():
    depth = int(input())
    leaves = [int(x) for x in input().split()]

    nodes_range = [None] * (depth + 1)
    for i in range(depth, -1, -1):
        if i == depth:
            nodes_range[i] = (leaves[i], leaves[i])
            continue
        
        min_nodes = math.ceil(nodes_range[i + 1][0] / 2) + leaves[i]
        
        max_nodes = nodes_range[i + 1][1] + leaves[i]
        nodes_range[i] = (min_nodes, max_nodes)

    if not nodes_range[0][0] != 1:
        
        print(-1)
        return

    max_noded_tree = [0] * (depth + 1)
    for i in range(depth + 1):
        if i == 0:
            max_noded_tree[i] = 1
            continue
        max_noded_tree[i] = min(
            (max_noded_tree[i - 1] - leaves[i - 1]) * 2,
            nodes_range[i][1])
    print(sum(max_noded_tree))
    return


if __name__ == '__main__':
    main()


Fixed, accepted submission:
import math


def main():
    depth = int(input())
    leaves = [int(x) for x in input().split()]

    nodes_range = [None] * (depth + 1)
    for i in range(depth, -1, -1):
        if i == depth:
            nodes_range[i] = (leaves[i], leaves[i])
            continue
        
        min_nodes = math.ceil(nodes_range[i + 1][0] / 2) + leaves[i]
        
        max_nodes = nodes_range[i + 1][1] + leaves[i]
        nodes_range[i] = (min_nodes, max_nodes)

    if nodes_range[0][0] != 1:
        
        print(-1)
        return

    max_noded_tree = [0] * (depth + 1)
    for i in range(depth + 1):
        if i == 0:
            max_noded_tree[i] = 1
            continue
        max_noded_tree[i] = min(
            (max_noded_tree[i - 1] - leaves[i - 1]) * 2,
            nodes_range[i][1])
    print(sum(max_noded_tree))
    return


if __name__ == '__main__':
    main()
Problem:
There are N children in AtCoder Kindergarten. Mr. Evi will arrange the children in a line, then give 1 candy to the first child in the line, 2 candies to the second child, ..., N candies to the N-th child. How many candies will be necessary in total?

Incorrect submission (verdict: Wrong Answer):
N=int(input())

i=0

for i in range(N):
  i+=1
  

Fixed, accepted submission:
a = int(input())

print(int(a*(a+1)/2))
Problem:
You are parking at a parking lot. You can choose from the following two fee plans:    * Plan 1: The fee will be A×T yen (the currency of Japan) when you park for T hours.   * Plan 2: The fee will be B yen, regardless of the duration.  Find the minimum fee when you park for N hours.

Incorrect submission (verdict: Wrong Answer):
n ,a ,b = map(int, input().split())
if a*n <= b:
    print(a*b)
else:
    print(b)

Fixed, accepted submission:
n ,a ,b = map(int, input().split())
if a*n <= b:
    print(a*n)
else:
    print(b)
Problem:
Given is a rooted tree with N vertices numbered 1 to N. The root is Vertex 1, and the i-th edge (1 \leq i \leq N - 1) connects Vertex a_i and b_i.  Each of the vertices has a counter installed. Initially, the counters on all the vertices have the value 0.  Now, the following Q operations will be performed:    * Operation j (1 \leq j \leq Q): Increment by x_j the counter on every vertex contained in the subtree rooted at Vertex p_j.  Find the value of the counter on each vertex after all operations.

Incorrect submission (verdict: Wrong Answer):
def resolve():
	from collections import deque
	
	n, q = map(int, input().split())
	adj = [[] for i in range(n+1)]
	for i in range(n-1):
		a, b = map(int, input().split())
		adj[a].append(b)
		adj[b].append(a)
	p = [list(map(int, input().split())) for i in range(q)]
	
	ans = [0 for i in range(n+1)]
	tmp = [0 for i in range(n+1)]
	for i in range(q):
		tmp[p[i][0]] += p[i][1]

	for start, point in enumerate(tmp):
		q = deque([start])
		while q:
			node = q.popleft()
			ans[node] += tmp[start]
			for i in list(filter(lambda x: x>node, adj[node])):
				q.append(i)

	for i in ans[1:]:
		print(i, end=" ")

resolve()

Fixed, accepted submission:
import sys
import io

sys.setrecursionlimit(10 ** 6)
def input():
    return sys.stdin.readline()[:-1]
    
def resolve():
	from collections import deque
	
	n, q = map(int, input().split())
	adj = [[] for i in range(n+1)]
	for i in range(n-1):
		a, b = map(int, input().split())
		adj[a-1].append(b-1)
		adj[b-1].append(a-1)
	ans = [0 for i in range(n)]
	for i in range(q):
		p, x = map(int, input().split())
		p -= 1
		ans[p] += x
#	print(f"{adj=}\n{ans=}")

	def dfs(now, prv):
		for next in adj[now]:
#			print(f"{now=}, {next=}")
			if next == prv:
				continue
			ans[next] += ans[now]
			dfs(next, now)

	dfs(0, 0)
	print(*ans)

resolve()
Problem:
There is a hotel with the following accommodation fee:    * X yen (the currency of Japan) per night, for the first K nights   * Y yen per night, for the (K+1)-th and subsequent nights  Tak is staying at this hotel for N consecutive nights. Find his total accommodation fee.

Incorrect submission (verdict: Wrong Answer):
n=int(input())
k=int(input())
x=int(input())
y=int(input())
if n>k:
    print(x+(n-k)*y)
else:
    print(x)

Fixed, accepted submission:
n=int(input())
k=int(input())
x=int(input())
y=int(input())
if n>k:
    print(k*x+(n-k)*y)
else:
    print(n*x)
Problem:
There are N positive integers written on a blackboard: A_1, ..., A_N.  Snuke can perform the following operation when all integers on the blackboard are even:    * Replace each integer X on the blackboard by X divided by 2.  Find the maximum possible number of operations that Snuke can perform.

Incorrect submission (verdict: Wrong Answer):
N = int(input())
A_list = list(map(int, input().split()))
A_list = sorted(A_list)
flag = True
cnt = 0
for i in range(N):
    if A_list[i]%2!=0:
        flag=False
        break
if flag:
    while (1):
        A_list[0]/=2
        cnt += 1
        if A_list[0]==1:
            break
print(cnt) if flag else print(0)

Fixed, accepted submission:
import numpy as np
N = int(input())
A_list = list(map(int, input().split()))
flag = True
cnt = 0
while(flag):
    for i in range(N):
        if A_list[i]%2!=0:
            flag=False
            break
        A_list[i]/=2
    cnt+=1
print(cnt-1)
Problem:
We conducted a survey on newspaper subscriptions. More specifically, we asked each of the N respondents the following two questions:    * Question 1: Are you subscribing to Newspaper X?   * Question 2: Are you subscribing to Newspaper Y?  As the result, A respondents answered "yes" to Question 1, and B respondents answered "yes" to Question 2.  What are the maximum possible number and the minimum possible number of respondents subscribing to both newspapers X and Y?  Write a program to answer this question.

Incorrect submission (verdict: Wrong Answer):
n,a,b=map(int,input().split())
if a+b>=n:
    print(a+b-n)
else:
    print(max(a,b))

Fixed, accepted submission:
n,a,b=map(int,input().split())
if a+b>=n:
    print(min(a,b),a+b-n)
else:
    print(min(a,b),0)
Problem:
You are given two positive integers A and B. Compare the magnitudes of these numbers.

Incorrect submission (verdict: Wrong Answer):
A = int(input())
B = int(input())

if A > B:
    print("GREATER")
if A == B:
    print("EQUAL")
else:
    print("LESS")


Fixed, accepted submission:
A = int(input())
B = int(input())

if A > B:
    print("GREATER")
elif A == B:
    print("EQUAL")
else:
    print("LESS")
Problem:
Snuke has decided to play with a six-sided die. Each of its six sides shows an integer 1 through 6, and two numbers on opposite sides always add up to 7.  Snuke will first put the die on the table with an arbitrary side facing upward, then repeatedly perform the following operation:    * Operation: Rotate the die 90° toward one of the following directions: left, right, front (the die will come closer) and back (the die will go farther). Then, obtain y points where y is the number written in the side facing upward.  For example, let us consider the situation where the side showing 1 faces upward, the near side shows 5 and the right side shows 4, as illustrated in the figure. If the die is rotated toward the right as shown in the figure, the side showing 3 will face upward. Besides, the side showing 4 will face upward if the die is rotated toward the left, the side showing 2 will face upward if the die is rotated toward the front, and the side showing 5 will face upward if the die is rotated toward the back.    Find the minimum number of operation Snuke needs to perform in order to score at least x points in total.

Incorrect submission (verdict: Wrong Answer):
num = int(input())
res = num % (6 + 5)
print("res",res)
itr = num // (6 + 5) * 2
print("itr",itr)
if res > 6:
    print(itr + 1 + 1)
elif res != 0 and res <= 6:
    print(itr + 1)
else:
    print(itr)


Fixed, accepted submission:
num = int(input())
res = num % (6 + 5)
#print("res",res)
itr = num // (6 + 5) * 2
#print("itr",itr)
if res > 6:
    print(itr + 1 + 1)
elif res != 0 and res <= 6:
    print(itr + 1)
else:
    print(itr)
Problem:
We will buy a product for N yen (the currency of Japan) at a shop.  If we use only 1000-yen bills to pay the price, how much change will we receive?  Assume we use the minimum number of bills required.

Incorrect submission (verdict: Wrong Answer):
print(int(input())%1000)

Fixed, accepted submission:
a = int(input())%1000
print(0 if a== 0 else 1000 - a)
Problem:
Snuke has decided to construct a string that starts with `A` and ends with `Z`, by taking out a substring of a string s (that is, a consecutive part of s).  Find the greatest length of the string Snuke can construct. Here, the test set guarantees that there always exists a substring of s that starts with `A` and ends with `Z`.

Incorrect submission (verdict: Wrong Answer):
s = input()
n = len(s)
ans = 0
for i in range(n):
    if s[i] == 'A':
        ans -= i
        break

for j in range(n-1, 0):
    if s[j] == 'Z':
        ans += j
        break

print(ans)


Fixed, accepted submission:
s = input()
n = len(s)
ans = 0
for i in range(n):
    if s[i] == 'A':
        ans -= i
##        print('i')
        break

for j in reversed(range(0, n)):
    if s[j] == 'Z':
        ans += j
        break

print(ans + 1)
Problem:
In programming languages like C/C++, a goto statement provides an unconditional jump from the "goto" to a labeled statement. For example, a statement "goto CHECK_NUM;" is executed, control of the program jumps to CHECK_NUM. Using these constructs, you can implement, for example, loops.  Note that use of goto statement is highly discouraged, because it is difficult to trace the control flow of a program which includes goto.  Write a program which does precisely the same thing as the following program (this example is wrtten in C++). Let's try to write the program without goto statements.                 void call(int n){   int i = 1;  CHECK_NUM:   int x = i;   if ( x % 3 == 0 ){     cout << " " << i;     goto END_CHECK_NUM;   }  INCLUDE3:   if ( x % 10 == 3 ){     cout << " " << i;     goto END_CHECK_NUM;   }   x /= 10;   if ( x ) goto INCLUDE3;  END_CHECK_NUM:   if ( ++i <= n ) goto CHECK_NUM;    cout << endl; }

Incorrect submission (verdict: Wrong Answer):
n = int(input())
for i in range(n + 1):
	if i % 3 == 0 or str(i).find("3") != -1:
		print(" {}".format(i), end = '')
print()


Fixed, accepted submission:
n = int(input())
for i in range(1, n + 1):
	if i % 3 == 0 or str(i).find("3") != -1:
		print(" {}".format(i), end = '')
print()
Problem:
We ask you to select some number of positive integers, and calculate the sum of them.  It is allowed to select as many integers as you like, and as large integers as you wish. You have to follow these, however: each selected integer needs to be a multiple of A, and you need to select at least one integer.  Your objective is to make the sum congruent to C modulo B. Determine whether this is possible.  If the objective is achievable, print `YES`. Otherwise, print `NO`.

Incorrect submission (verdict: Wrong Answer):
import math
a, b, c = map(int,input().split())

for i in range(10**7):
    n = a * i
    if n % b == c:
        print('Yes')
        quit()
print('No')

Fixed, accepted submission:
import math
a, b, c = map(int,input().split())

for i in range(10**5):
    n = a * i
    if n % b == c:
        print('YES')
        quit()
print('NO')
Problem:
Evi has N integers a_1,a_2,..,a_N. His objective is to have N equal **integers** by transforming some of them.  He may transform each integer at most once. Transforming an integer x into another integer y costs him (x-y)^2 dollars. Even if a_i=a_j (i≠j), he has to pay the cost separately for transforming each of them (See Sample 2).  Find the minimum total cost to achieve his objective.

Incorrect submission (verdict: Wrong Answer):
N = input()
l = list(map(int,list(input().split())))
cost_min = (200**2)*100
cost = 0
for i in range(-100,101):
    for j in l:
        cost = (j - i)**2
        if cost < cost_min:
            cost_min = cost
print(cost_min)


Fixed, accepted submission:
N = input()
l = list(map(int,list(input().split())))
cost_min = (200**2)*100
cost = 0
for i in range(-100,101):
    for j in l:
        cost += (j - i)**2
        
    if cost < cost_min:
        cost_min = cost
    cost = 0
print(cost_min)
Problem:
There is a rectangle in the xy-plane, with its lower left corner at (0, 0) and its upper right corner at (W, H). Each of its sides is parallel to the x-axis or y-axis. Initially, the whole region within the rectangle is painted white.  Snuke plotted N points into the rectangle. The coordinate of the i-th (1 ≦ i ≦ N) point was (x_i, y_i).  Then, he created an integer sequence a of length N, and for each 1 ≦ i ≦ N, he painted some region within the rectangle black, as follows:    * If a_i = 1, he painted the region satisfying x < x_i within the rectangle.   * If a_i = 2, he painted the region satisfying x > x_i within the rectangle.   * If a_i = 3, he painted the region satisfying y < y_i within the rectangle.   * If a_i = 4, he painted the region satisfying y > y_i within the rectangle.  Find the area of the white region within the rectangle after he finished painting.

Incorrect submission (verdict: Wrong Answer):
w,h,n=map(int,input().split())
xya=[[int(i) for i in input().split()] for j in range(n)]

minx=w
maxx=0
miny=h
maxy=0
for x,y,a in xya:
    if a==2:
        maxx=max(maxx,x)
    elif a==1:
        minx=min(minx,x)
    elif a==4:
        maxy=max(maxy,y)
    elif a==3:
        miny=min(miny,y)

x=max(0,maxx-minx)
y=max(0,maxy-miny)
print(x*y)

Fixed, accepted submission:
w,h,n=map(int,input().split())
xya=[[int(i) for i in input().split()] for j in range(n)]

minx=w
maxx=0
miny=h
maxy=0
for x,y,a in xya:
    if a==1:
        maxx=max(maxx,x)
    elif a==2:
        minx=min(minx,x)
    elif a==3:
        maxy=max(maxy,y)
    elif a==4:
        miny=min(miny,y)

x=max(0,minx-maxx)
y=max(0,miny-maxy)
print(x*y)
Problem:
Let f(n) be the number of triples of integers (x,y,z) that satisfy both of the following conditions:    * 1 \leq x,y,z   * x^2 + y^2 + z^2 + xy + yz + zx = n  Given an integer N, find each of f(1),f(2),f(3),\ldots,f(N).

Incorrect submission (verdict: Wrong Answer):
import numpy as np


def main(N):
    f = [0]*(N+1)
    for x in range(100):
        for y in range(100):
            for z in range(100):
                if (x+y+2)**2+(x+z+2)**2+(z+y+2)**2 > 2*N:
                    break
                f[((x+y+2)**2+(x+z+2)**2+(z+y+2)**2)//2] += 1
    return f


N = int(input())
f = main(N)
for num in f:
    print(num)


Fixed, accepted submission:
import numpy as np


def main(N):
    f = [0]*(N+1)
    for x in range(100):
        for y in range(100):
            for z in range(100):
                if (x+y+2)**2+(x+z+2)**2+(z+y+2)**2 > 2*N:
                    break
                f[((x+y+2)**2+(x+z+2)**2+(z+y+2)**2)//2] += 1
    return f


N = int(input())
f = main(N)
for i in range(N):
    print(f[i+1])
Problem:
Write a program which reads three integers a, b and c, and prints the number of divisors of c between a and b.

Incorrect submission (verdict: Wrong Answer):
a, b, c = map(int, input().split())
cnt = 0
for i in range(a, b+1):
    if i%c == 0:
        cnt += 1
print(cnt)


Fixed, accepted submission:
a, b, c = map(int, input().split())
cnt = 0
for i in range(a, b+1):
    if c%i == 0:
        cnt += 1
print(cnt)
Problem:
You are given N integers; the i-th of them is A_i. Find the maximum possible sum of the absolute differences between the adjacent elements after arranging these integers in a row in any order you like.

Incorrect submission (verdict: Wrong Answer):
import sys
iN = int(input())

aA = sorted([int(_) for _ in sys.stdin.readlines()])
aInvA = list(reversed(aA))

iDiff = aInvA[0] - aA[0]
for i in range(1,iN//2 + 1 ):
    D1 = aInvA[i] - aA[i-1]
    D2 = aInvA[i-1] - aA[i]
    if D1 :
        iDiff += D1
    if D2:
        iDiff += D2

print(iDiff)


Fixed, accepted submission:
import sys
iN = int(input())

aA = sorted([int(_) for _ in sys.stdin.readlines()])



if iN % 2 == 0:
    iH = iN // 2
    print( -2 * sum(aA[0:iH-1]) - aA[iH-1] + aA[iH] + 2* sum(aA[iH+1:]))
else:
    iH = (iN -1) //2
    iBigStart = -2 * sum(aA[0:iH]) + aA[iH] + aA[iH+1] + 2 * sum(aA[iH+2:])
    iSmallStart = -2 * sum(aA[0:iH-1]) - aA[iH-1] -aA[iH] + 2* sum(aA[iH+1:])
    print(max(iBigStart,iSmallStart))

exit()
Problem:
We have a grid with H rows and W columns. At first, all cells were painted white.  Snuke painted N of these cells. The i-th ( 1 \leq i \leq N ) cell he painted is the cell at the a_i-th row and b_i-th column.  Compute the following:    * For each integer j ( 0 \leq j \leq 9 ), how many subrectangles of size 3×3 of the grid contains exactly j black cells, after Snuke painted N cells?

Incorrect submission (verdict: Wrong Answer):
H,W,N = map(int,input().split())

A = {}
for i in range(N):
  a,b = map(int,input().split())
  a-=1;b-=1
  for t in range(3):
    for s in range(3):
      if 0<=a-t<H-2 and 0<=b-s<W-2:
        if (a-t,b-s) not in A:
          A[(a-t,b-s)]  = 1
        else:
          A[(a-t,b-s)]  += 1
#print(A)
ans = [-1]
temp = list(A.values())
total = 0
for i in range(1,9):
  c = temp.count(i)
  total += c
  ans.append(c)
ans[0] = (H-2)*(W-2)-total
print(*ans, sep="\n")

  

Fixed, accepted submission:
H,W,N = map(int,input().split())

A = {}
for i in range(N):
  a,b = map(int,input().split())
  a-=1;b-=1
  for t in range(3):
    for s in range(3):
      if 0<=a-t<H-2 and 0<=b-s<W-2:
        if (a-t,b-s) not in A:
          A[(a-t,b-s)]  = 1
        else:
          A[(a-t,b-s)]  += 1
#print(A)
ans = [-1]
temp = list(A.values())
total = 0
for i in range(1,10):
  c = temp.count(i)
  total += c
  ans.append(c)
ans[0] = (H-2)*(W-2)-total
print(*ans, sep="\n")