TnT/CodeNet4Repair huggingface dataset:
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):
N = int(input())

res = N // 1000

print(res)

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

reminder = N % 1000

if reminder:
  res = 1000 - reminder
  print(res)
else:
  print(0)
Problem:
You are playing the following game with Joisino.    * Initially, you have a blank sheet of paper.   * Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.   * Then, you are asked a question: How many numbers are written on the sheet now?  The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?

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

d = {}
for i in range(n):
    a = int(input())
    if a in d:
        d[a] ^= 1
print(sum(d.values()))

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

d = {}
for i in range(n):
    a = int(input())
    if a in d:
        d[a] ^= 1
    else:
        d[a] = 1
print(sum(d.values()))
Problem:
We will call a string that can be obtained by concatenating two equal strings an _even_ string. For example, `xyzxyz` and `aaaaaa` are even, while `ababab` and `xyzxy` are not.  You are given an even string S consisting of lowercase English letters. Find the length of the longest even string that can be obtained by deleting one or more characters from the end of S. It is guaranteed that such a non-empty string exists for a given input.

Incorrect submission (verdict: Wrong Answer):
S=input()

for i in reversed(range(len(S))):
  if i % 2 == 1:
    moji1 = S[0:i//2 + 1]
    moji2 = S[i//2 + 1: i+ 1]
    if moji1==moji2:
      print(i+1)
      break

Fixed, accepted submission:
S = input()
for i in range(len(S)-2, -1, -2):
    if S[:i//2] == S[i//2:i]:
        print(i)
        break
Problem:
You are given three strings A, B and C. Check whether they form a _word chain_.  More formally, determine whether both of the following are true:    * The last character in A and the initial character in B are the same.   * The last character in B and the initial character in C are the same.  If both are true, print `YES`. Otherwise, print `NO`.

Incorrect submission (verdict: Wrong Answer):
a, b, c = input().split()
def check(a, b, c):
    if a[-1] == b[0] and b[-1] == c[0]:
        return True
    return False
print('Yes' if check(a, b, c) else 'No')


Fixed, accepted submission:
a, b, c = input().split()
def check(a, b, c):
    if a[-1] == b[0] and b[-1] == c[0]:
        return True
    return False
print('YES' if check(a, b, c) else 'NO')
Problem:
We will say that two integer sequences of length N, x_1, x_2, ..., x_N and y_1, y_2, ..., y_N, are _similar_ when |x_i - y_i| \leq 1 holds for all i (1 \leq i \leq N).  In particular, any integer sequence is similar to itself.  You are given an integer N and an integer sequence of length N, A_1, A_2, ..., A_N.  How many integer sequences b_1, b_2, ..., b_N are there such that b_1, b_2, ..., b_N is similar to A and the product of all elements, b_1 b_2 ... b_N, is even?

Incorrect submission (verdict: Wrong Answer):
i=int(input())
s=input().split()
j=[]
k=[]
a=0
for h in range(i):
  j.append(int(s[h])%2)
for g in range(i):
  plus=1
  if j[g]==0:
    if len(k)>0:
      for h in k:
        plus=plus*h
    plus=plus*(3^(9-g))
    a+=plus
    k.append(2)
  else:
    if len(k)>0:
      for h in k:
        plus=plus*h
    plus=2*plus*(3^(9-g))
    a+=plus
    k.append(1)
print(str(a))


Fixed, accepted submission:
n=int(input())
ls=list(map(int,input().split()))
prev=1
ans=0
for i in range(n):
  k=ls[i]
  if k%2==1:
    ans+=prev*2*(3**(n-i-1))
  else:
    ans+=prev*3**(n-i-1)
    prev*=2
print(ans)
Problem:
You are given three strings A, B and C. Each of these is a string of length N consisting of lowercase English letters.  Our objective is to make all these three strings equal. For that, you can repeatedly perform the following operation:    * Operation: Choose one of the strings A, B and C, and specify an integer i between 1 and N (inclusive). Change the i-th character from the beginning of the chosen string to some other lowercase English letter.  What is the minimum number of operations required to achieve the objective?

Incorrect submission (verdict: Wrong Answer):
N = int(input())
A = input()
B = input()
C = input()
cnt = 0

for idx in range(N):
    if A[idx] == B[idx] and A[idx] == C[idx] and B[idx] == C[idx]:
        print(0)
        continue
    elif A[idx] == B[idx]:
        C = C[:idx] + A[idx] + C[idx+1:]
        cnt += 1
    elif A[idx] == C[idx]:
        B = B[:idx] + A[idx] + B[idx+1:]
        cnt += 1
    elif B[idx] == C[idx]:
        A = A[:idx] + B[idx] + A[idx+1:]
        cnt += 1
    else:
        B = B[:idx] + A[idx] + B[idx+1:]
        C = C[:idx] + A[idx] + C[idx+1:]
        cnt += 2
#print(A,B,C)
print(cnt)

Fixed, accepted submission:
N = int(input())
A = input()
B = input()
C = input()
cnt = 0

for idx in range(N):
    if A[idx] == B[idx] and A[idx] == C[idx] and B[idx] == C[idx]:
        continue
    elif A[idx] == B[idx]:
        C = C[:idx] + A[idx] + C[idx+1:]
        cnt += 1
    elif A[idx] == C[idx]:
        B = B[:idx] + A[idx] + B[idx+1:]
        cnt += 1
    elif B[idx] == C[idx]:
        A = A[:idx] + B[idx] + A[idx+1:]
        cnt += 1
    else:
        B = B[:idx] + A[idx] + B[idx+1:]
        C = C[:idx] + A[idx] + C[idx+1:]
        cnt += 2
#print(A,B,C)
print(cnt)
Problem:
Write a program of the Insertion Sort algorithm which sorts a sequence A in ascending order. The algorithm should be based on the following pseudocode:                 for i = 1 to A.length-1     key = A[i]     /* insert A[i] into the sorted sequence A[0,...,j-1] */     j = i - 1     while j >= 0 and A[j] > key         A[j+1] = A[j]         j--     A[j+1] = key   Note that, indices for array elements are based on 0-origin.  To illustrate the algorithms, your program should trace intermediate result for each step.

Incorrect submission (verdict: Wrong Answer):
N = int(input())
A = [int(i) for i in input().split()]

def insertionSort(A, N):
    for i in range(N):
        v = A[i]
        j = i - 1
        while j >= 0 and A[j] > v:
            A[j+1] = A[j]
            j -= 1
        A[j+1] = v
        print(A)

insertionSort(A, N)

Fixed, accepted submission:
N = int(input())
A = [int(i) for i in input().split()]

def insertionSort(A, N):
    for i in range(N):
        v = A[i]
        j = i - 1
        while j >= 0 and A[j] > v:
            A[j+1] = A[j]
            j -= 1
        A[j+1] = v
        print(' '.join([str(i) for i in A]))

insertionSort(A, N)
Problem:
Find the number of _palindromic numbers_ among the integers between A and B (inclusive). Here, a palindromic number is a positive integer whose string representation in base 10 (without leading zeros) reads the same forward and backward.

Incorrect submission (verdict: Wrong Answer):
a,b = [int(x) for x in input().split()]

def ip(n):
  s = list(str(n))
  r = s
  r.reverse()
  return r == s

ans = 0
for i in range(a,b+1):
  if ip(i): ans += 1
print(ans)

Fixed, accepted submission:
a,b = [int(x) for x in input().split()]

def ip(n):
  r = list(str(n))
  r.reverse()
  return r == list(str(n))

ans = 0
for i in range(a,b+1):
  if ip(i): ans += 1
print(ans)
Problem:
A balance scale tips to the left if L>R, where L is the total weight of the masses on the left pan and R is the total weight of the masses on the right pan. Similarly, it balances if L=R, and tips to the right if L<R.  Takahashi placed a mass of weight A and a mass of weight B on the left pan of a balance scale, and placed a mass of weight C and a mass of weight D on the right pan.  Print `Left` if the balance scale tips to the left; print `Balanced` if it balances; print `Right` if it tips to the right.

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

m=a+b
n=c+d

if m>n:
  print("left")
elif m==n:
  print("balanced")
else:
  print("left")

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

m=a+b
n=c+d

if m>n:
  print("Left")
elif m==n:
  print("Balanced")
else:
  print("Right")
Problem:
Find the largest square number not exceeding N. Here, a _square number_ is an integer that can be represented as the square of an integer.

Incorrect submission (verdict: Wrong Answer):

def main():
    N = int(input())

    num = 1
    for i in range(1,6):
        if N >= (10**i)**2 and N < (10**(i+1))**2:
            for j in range(10**i, 10**(i+1)):
               if j**2 > 10**9 or j**2 > N:
                   print (num)
                   return
               else:
                   num = j**2
               

    print (num)


if __name__ == "__main__":
    # global stime
    # stime = time.clock()
    main()


Fixed, accepted submission:

def main():
    N = int(input())

    num = 1
    for i in range(6):
        if N >= (10**i)**2 and N < (10**(i+1))**2:
            for j in range(10**i, 10**(i+1)):
               if j**2 > 10**9 or j**2 > N:
                   print (num)
                   return
               else:
                   num = j**2
               

    print (num)


if __name__ == "__main__":
    # global stime
    # stime = time.clock()
    main()
Problem:
There are N balls in the xy-plane. The coordinates of the i-th of them is (x_i, i). Thus, we have one ball on each of the N lines y = 1, y = 2, ..., y = N.  In order to collect these balls, Snuke prepared 2N robots, N of type A and N of type B. Then, he placed the i-th type-A robot at coordinates (0, i), and the i-th type-B robot at coordinates (K, i). Thus, now we have one type-A robot and one type-B robot on each of the N lines y = 1, y = 2, ..., y = N.  When activated, each type of robot will operate as follows.    * When a type-A robot is activated at coordinates (0, a), it will move to the position of the ball on the line y = a, collect the ball, move back to its original position (0, a) and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.    * When a type-B robot is activated at coordinates (K, b), it will move to the position of the ball on the line y = b, collect the ball, move back to its original position (K, b) and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.  Snuke will activate some of the 2N robots to collect all of the balls. Find the minimum possible total distance covered by robots.

Incorrect submission (verdict: Wrong Answer):
n = int(input())
k = int(input())
li = list(map(int,input().split()))
num = 0
for i in range(n):
  num += max(abs(li[i]),abs(k-li[i]))
print(num)


Fixed, accepted submission:
n = int(input())
k = int(input())
li = list(map(int,input().split()))
num = 0
for i in range(n):
  num += min(abs(li[i]),abs(k-li[i]))
print(num*2)
Problem:
Takahashi is participating in a programming contest called AXC002, and he has just submitted his code to Problem A.  The problem has N test cases.  For each test case i (1\leq i \leq N), you are given a string S_i representing the verdict for that test case. Find the numbers of test cases for which the verdict is `AC`, `WA`, `TLE`, and `RE`, respectively.  See the Output section for the output format.

Incorrect submission (verdict: Wrong Answer):
N = int(input())
S = []
for i in range(N):
    S.append((input()))

ac = str(S.count('AC'))
wa = str(S.count('WA'))
tle = str(S.count('TLE'))
re = str(S.count('TLE'))


ans = 'AC x'+' '+ ac + "\n"+'WA x'+' '+ wa + "\n"+'TLE x' +' '+ tle +"\n" + 'RE x'+' '+re
print(ans)

Fixed, accepted submission:
N = int(input())
S = []
for i in range(N):
    S.append((input()))

ac = str(S.count('AC'))
wa = str(S.count('WA'))
tle = str(S.count('TLE'))
re = str(S.count('RE'))


ans = 'AC x'+' '+ ac + "\n"+'WA x'+' '+ wa + "\n"+'TLE x' +' '+ tle +"\n" + 'RE x'+' '+re

print(ans)
Problem:
Niwango created a playlist of N songs. The title and the duration of the i-th song are s_i and t_i seconds, respectively. It is guaranteed that s_1,\ldots,s_N are all distinct.  Niwango was doing some work while playing this playlist. (That is, all the songs were played once, in the order they appear in the playlist, without any pause in between.) However, he fell asleep during his work, and he woke up after all the songs were played. According to his record, it turned out that he fell asleep at the very end of the song titled X.  Find the duration of time when some song was played while Niwango was asleep.

Incorrect submission (verdict: Wrong Answer):
import sys

input = sys.stdin.readline

# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np


def main():
	n=int(input())
	s=[]
	t=[]
	for i in range(n):
		a,b=input().split()
		s.append(a)
		t.append(int(b))
	x=input()

	for i in range(n):
		if x==s[i]:
			print(sum(t[i+1:]))
			exit(0)













if __name__ == "__main__":
	main()


Fixed, accepted submission:
import sys


# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np


def main():
	n=int(input())
	s=[]
	t=[]
	for i in range(n):
		a,b=input().split()
		s.append(a)
		t.append(int(b))
	x=input()
	for i in range(n):
		if x==s[i]:
			print(sum(t[i+1:]))


if __name__ == "__main__":
	main()
Problem:
We have a 3 \times 3 grid. A number c_{i, j} is written in the square (i, j), where (i, j) denotes the square at the i-th row from the top and the j-th column from the left.   According to Takahashi, there are six integers a_1, a_2, a_3, b_1, b_2, b_3 whose values are fixed, and the number written in the square (i, j) is equal to a_i + b_j.   Determine if he is correct.

Incorrect submission (verdict: Wrong Answer):
a = [list(map(int,input().split())) for i in range(3)]
if a[0][0]-a[1][0] == a[0][1]-a[1][1] == a[0][2]-a[1][2] and a[1][0]-a[2][0] == a[1][1]-a[2][1] == a[1][2] == a[2][2]:
  print("Yes")
else:
  print("No")

Fixed, accepted submission:
a = [list(map(int,input().split())) for i in range(3)]
if a[0][0]-a[1][0] == a[0][1]-a[1][1] == a[0][2]-a[1][2] and a[1][0]-a[2][0] == a[1][1]-a[2][1] == a[1][2]-a[2][2]:
  print("Yes")
else:
  print("No")
Problem:
Print all the integers that satisfies the following in ascending order:    * Among the integers between A and B (inclusive), it is either within the K smallest integers or within the K largest integers.

Incorrect submission (verdict: Wrong Answer):
a, b, k = map(int, input().split())
X = []
for i in range(a, min(a+k, b)):
    X.append(i)

for j in range(max(b-k+1, a+1), b+1):
    X.append(j)

X_s = set(X)
for k in X_s:
    print(k)

Fixed, accepted submission:
a, b, k = map(int, input().split())
X = []
for i in range(a, min(a+k, b+1)):
    X.append(i)

for j in range(max(b-k+1, a), b+1):
    X.append(j)
X = sorted(X)
X_s = sorted(set(X), key=X.index)
for k in X_s:
    print(k)
Problem:
On a two-dimensional plane, there are N red points and N blue points. The coordinates of the i-th red point are (a_i, b_i), and the coordinates of the i-th blue point are (c_i, d_i).  A red point and a blue point can form a _friendly pair_ when, the x-coordinate of the red point is smaller than that of the blue point, and the y-coordinate of the red point is also smaller than that of the blue point.  At most how many friendly pairs can you form? Note that a point cannot belong to multiple pairs.

Incorrect submission (verdict: Wrong Answer):
from bisect import bisect

N = int(input())
red, blue = [], []
for _ in range(N):
    red.append(tuple(int(i) for i in input().split()))
for _ in range(N):
    blue.append(tuple(int(i) for i in input().split()))
pair = []

red.sort(key=lambda x: x[0])
blue.sort(reverse=True,key=lambda x: x[0])
r = [po[0] for po in red]

for point in blue:
    mxred = bisect(r,point[0])
    re = red[:mxred]
    re.sort(reverse=True, key=lambda x: x[1])
    for i in range(len(re)):
        if re[i][1] < point[1] and re[i] not in pair:
            pair.append(re[i])
            print(re[i],point)
            break

print(len(pair))

Fixed, accepted submission:
N = int(input())
red, blue = [], []
for _ in range(N):
    red.append(tuple(int(i) for i in input().split()))
for _ in range(N):
    blue.append(tuple(int(i) for i in input().split()))
ans = 0

red.sort(reverse=True,key=lambda x: x[0])
blue.sort(key=lambda x: x[1])

for bl in blue:
    for re in red:
        if re[0] < bl[0] and re[1] < bl[1]:
            ans += 1
            red.remove(re)
            break

print(ans)
Problem:
Let's arrange a deck of cards. There are totally 36 cards of 4 suits(S, H, C, D) and 9 values (1, 2, ... 9). For example, 'eight of heart' is represented by H8 and 'one of diamonds' is represented by D1.  Your task is to write a program which sorts a given set of cards in ascending order by their values using the Bubble Sort algorithms and the Selection Sort algorithm respectively. These algorithms should be based on the following pseudocode:                 BubbleSort(C) 1 for i = 0 to C.length-1 2     for j = C.length-1 downto i+1 3         if C[j].value < C[j-1].value 4             swap C[j] and C[j-1]                 SelectionSort(C) 1 for i = 0 to C.length-1 2     mini = i 3     for j = i to C.length-1 4         if C[j].value < C[mini].value 5             mini = j 6     swap C[i] and C[mini]   Note that, indices for array elements are based on 0-origin.  For each algorithm, report the stability of the output for the given input (instance). Here, 'stability of the output' means that: cards with the same value appear in the output in the same order as they do in the input (instance).

Incorrect submission (verdict: Wrong Answer):
def bubble_sort(c, n):
    x = c[:]
    for i in range(n):
        for k in range(n-1, i, -1):
            if x[k][1] < x[k-1][1]:
                x[k], x[k-1] = x[k-1], x[k]
    return x

def selection_sort(c, n):
    x = c[:]
    for i in range(n):
        mink = i
        for k in range(i, n):
            if x[k][1] < x[mink][1]:
                mink = k
        x[i], x[mink] = x[mink], x[i]
    return x

n = int(input())
c = []
for i in list(input().split()):
    c.append((i[0], int(i[1]))) 

b = bubble_sort(c, n)
print(" ".join(map(str, [i[0]+str(i[1]) for i in b])))

stable = True
print("Stable")

s = selection_sort(c, n)
print(" ".join(map(str, [i[0]+str(i[1]) for i in s])))
if b != s:
    stable = False
if stable:
    print("Stable")
else:
    print("Not Stable")


Fixed, accepted submission:
def bubble_sort(c, n):
    x = c[:]
    for i in range(n):
        for k in range(n-1, i, -1):
            if x[k][1] < x[k-1][1]:
                x[k], x[k-1] = x[k-1], x[k]
    return x

def selection_sort(c, n):
    x = c[:]
    for i in range(n):
        mink = i
        for k in range(i, n):
            if x[k][1] < x[mink][1]:
                mink = k
        x[i], x[mink] = x[mink], x[i]
    return x

n = int(input())
c = []
for i in list(input().split()):
    c.append((i[0], int(i[1]))) 

b = bubble_sort(c, n)
print(" ".join(map(str, [i[0]+str(i[1]) for i in b])))

stable = True
print("Stable")

s = selection_sort(c, n)
print(" ".join(map(str, [i[0]+str(i[1]) for i in s])))
if b != s:
    stable = False
if stable:
    print("Stable")
else:
    print("Not stable")
Problem:
M-kun is a competitor in AtCoder, whose highest rating is X.   In this site, a competitor is given a _kyu_ (class) according to his/her highest rating. For ratings from 400 through 1999, the following kyus are given:    * From 400 through 599: 8-kyu   * From 600 through 799: 7-kyu   * From 800 through 999: 6-kyu   * From 1000 through 1199: 5-kyu   * From 1200 through 1399: 4-kyu   * From 1400 through 1599: 3-kyu   * From 1600 through 1799: 2-kyu   * From 1800 through 1999: 1-kyu  What kyu does M-kun have?

Incorrect submission (verdict: Wrong Answer):
X = int(input())
up = 599
down = 400
i=8
while(X <= 400 and X >= 1999):
    if(X <= up and X >= down):
        print(i)
        break
    else:
        up += 200
        down += 200
        i-=1

Fixed, accepted submission:
X = int(input())
up = 599
down = 400
i=8
while(i>=1):
    if(X <= up and X >= down):
        print(i)
        break
    else:
        up += 200
        down += 200
        i -= 1
Problem:
Snuke signed up for a new website which holds programming competitions. He worried that he might forget his password, and he took notes of it. Since directly recording his password would cause him trouble if stolen, he took two notes: one contains the characters at the odd-numbered positions, and the other contains the characters at the even-numbered positions.  You are given two strings O and E. O contains the characters at the odd- numbered positions retaining their relative order, and E contains the characters at the even-numbered positions retaining their relative order. Restore the original password.

Incorrect submission (verdict: Wrong Answer):
o = input()
e = input()
for i,j in zip(o,e):
    print(i+j,end='')

Fixed, accepted submission:
o=list(input())
e=list(input())

ans=[]
if len(o)==len(e):
    for i in range(len(o)):
        ans.append(o[i])
        ans.append(e[i])
    print(''.join(ans))
else:
    for i in range(len(e)):
        ans.append(o[i])
        ans.append(e[i])
    ans.append(o[-1])
    print(''.join(ans))
Problem:
There are N dishes of cuisine placed in front of Takahashi and Aoki. For convenience, we call these dishes Dish 1, Dish 2, ..., Dish N.  When Takahashi eats Dish i, he earns A_i points of _happiness_ ; when Aoki eats Dish i, she earns B_i points of happiness.  Starting from Takahashi, they alternately choose one dish and eat it, until there is no more dish to eat. Here, both of them choose dishes so that the following value is maximized: "the sum of the happiness he/she will earn in the end" minus "the sum of the happiness the other person will earn in the end".  Find the value: "the sum of the happiness Takahashi earns in the end" minus "the sum of the happiness Aoki earns in the end".

Incorrect submission (verdict: Wrong Answer):
n = int(input())
a = []
for i in range(n):
  a1,a2 = map(int, input().split())
  a.append([a1+a2,a1,a2])
a.sort()
a.reverse()
ans = 0
print(a)
for i in range(n):
  if i % 2 == 0:
    ans += a[i//2][1]
  else:
    ans -= a[i//2 + 1][2]
print(ans)

Fixed, accepted submission:
n = int(input())
a = []
for i in range(n):
  a1,a2 = map(int, input().split())
  a.append([a1+a2,a1,a2])
a.sort()
a.reverse()
ans = 0
for i in range(n):
  if i % 2 == 0:
    ans += a[i][1]
  else:
    ans -= a[i][2]
print(ans)
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):
N = int(input())

v = (N % 1000)
print(v)

Fixed, accepted submission:
N = int(input())
v = (N % 1000)

if v != 0:
    v = 1000 - v


print(v)
Problem:
In _K-city_ , there are n streets running east-west, and m streets running north-south. Each street running east-west and each street running north-south cross each other. We will call the smallest area that is surrounded by four streets a block. How many blocks there are in K-city?

Incorrect submission (verdict: Wrong Answer):
n, m = map(int, input().split())
print(n * m)

Fixed, accepted submission:
n, m = map(int, input().split())
print((n-1) * (m -1))
Problem:
You are given a positive integer X. Find the largest _perfect power_ that is at most X. Here, a perfect power is an integer that can be represented as b^p, where b is an integer not less than 1 and p is an integer not less than 2.

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

for i in range(32):
    if X < i * i:
        print((i-1) * (i-1))
    

Fixed, accepted submission:
import sys

X = int(input())
array = []
for i in range(2, 11):
    for j in range(1, 33):
        if pow(j, i) > X:
            break
        else:
            array.append(pow(j, i))
        
print(max(array))