Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
sx,sy,tx,ty=map(int,input().split())
x=tx-sx
y=ty-sy
if x>0 and y>0:
    for k in range(y):
        print(u)
    for k in range(x+1):
        print(r)
    for k in range(y+1):
        print(d)
    for k in range(x+1):
        print(l)
    print(u)
    print(l)
    for k in range(y+1):
        print(u)
    for k in range(x+1):
        print(r)
    for k in range(y+1):
        print(d)
    print(l)

Fixed submission:
sx,sy,tx,ty=map(int,input().split())
x=tx-sx
y=ty-sy
ans=""
for k in range(y):
    ans+="U"
for k in range(x+1):
    ans+="R"
for k in range(y+1):
    ans+="D"
for k in range(x+1):
    ans+="L"
ans+="U"
ans+="L"
for k in range(y+1):
    ans+="U"
for k in range(x+1):
    ans+="R"
for k in range(y+1):
    ans+="D"
for k in range(x):
    ans+="L"
print(ans)
Buggy python submission (verdict: Runtime Error):
N=int(input())
A=list(map(int,input().split()))
A.sort()
ans=1
mod=10**9+7
if N%2==0:
    for k in range(N//2):
        if A[2*k]==2*k+1 and A[2*k+1]==2*k+1:
            ans=ans*2%mod
            continue
        else:
            ans=0
            break
if N%2==1:
    if A[0]==0:
        ans=2
        for k in range(N//2-1):
            if A[2*k+2]==2*k+2 and A[2*k+1]==2*k+2:
                ans=ans*2%mod
                continue
            else:
                ans=0
                break
    else:
        ans=0
if N==1:
    if A[0]==0:
        ans=1
    else:
        ans=0
print(ans)

Fixed submission:
A,op,B=map(str,input().split())
A=int(A)
B=int(B)
if op=="+":
    print(A+B)
else:
    print(A-B)
Buggy python submission (verdict: Runtime Error):
H,W=map(int, input().split())
C=["0" for k in range(W)]
for k in range(H):
    C[k]=input()
D=["0"for k in range(2*H)]
for k in range(H):
    D[2*k]=C[k]
    D[2*k+1]=C[k]
for k in range(2*H):
    print(D[k])

Fixed submission:
H,W=map(int, input().split())
C=["0" for k in range(H)]
for k in range(H):
    C[k]=input()
D=["0"for k in range(2*H)]
for k in range(H):
    D[2*k]=C[k]
    D[2*k+1]=C[k]
for k in range(2*H):
    print(D[k])
Buggy python submission (verdict: Time Limit Exceeded):
A,B,X=map(int,input().split())
ans=0
for k in range(A,B+1):
    if k%X==0:
        ans +=1
print(ans)

Fixed submission:
A,B,X=map(int,input().split())
a=A%X
b=B%X
if a!=0:
    A=A+X-a
if b!=0:
    B=B-b
print((B-A)//X+1)
Buggy python submission (verdict: Time Limit Exceeded):
N,x=map(int,input().split())
A=list(map(int,input().split()))
B=[[0 for k in range(N)]for k in range(x+1)]
for k in range(x+1):
    for n in range(N):
        if n%2==0:
            B[k][n]=x-k
        else:
            B[k][n]=k
#print(B)

ans=[0 for k in range(x+1)]
for k in range(x+1):
    for n in range(N):
        if A[n]-B[k][n]>0:
            ans[k] +=A[n]-B[k][n]

print(min(ans))

Fixed submission:
N,x=map(int,input().split())
A=list(map(int,input().split()))
import copy
C=copy.copy(A)
B=[0 for k in range(N-1)]
for k in range(N-1):
    B[k]=A[k]+A[k+1]
#print(B)
for k in range(N-1):
    if B[k]-x>0:
        if B[k]-x>A[k+1]:
            A[k]=x
            A[k+1]=0
        else:
            A[k+1]=A[k+1]-B[k]+x
        if k!=N-2:
            B[k+1]=A[k+1]+A[k+2]
#print(A)
ans=0
for k in range(N):
    ans+=C[k]-A[k]
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
TT=0
AA=0
for k in range(N):
    T,A = map(int,input().split())
    k=min(TT//T,AA//A)
    for k in range(100000000000000000):
        k+=1
        if T*k>=TT and A*k>=AA:
            TT=T*k 
            AA=A*k
            break
print(TT+AA)

Fixed submission:
N = int(input())
TT,AA= map(int,input().split())
for k in range(1,N):
    T,A = map(int,input().split())
    j = max((TT-1+T)//T,(AA-1+A)//A)
    TT = T*j 
    AA = A*j
        
print(TT + AA)

Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
TT=0
AA=0
for k in range(N):
    T,A = map(int,input().split())
    k=0
    for k in range(100000000000000000):
        k+=1
        if T*k>=TT and A*k>=AA:
            TT=T*k 
            AA=A*k
            break
print(TT+AA)

Fixed submission:
N = int(input())
TT,AA= map(int,input().split())
for k in range(1,N):
    T,A = map(int,input().split())
    j = max((TT-1+T)//T,(AA-1+A)//A)
    TT = T*j 
    AA = A*j
        
print(TT + AA)
Buggy python submission (verdict: Time Limit Exceeded):
n, m = map(int, input().split())
groups = []
flag = [0 for i in range(n)]
for i in range(m):
    a, b = map(int, input().split())
    temp = {a, b}
    if flag[a-1] == 1 or flag[b-1] == 1:
        for j in range(len(groups)):
            if temp & groups[j]:
                groups[j] |= temp
    else:
        groups.append(temp)
    flag[a-1] = 1
    flag[b-1] = 1

print(len(groups)+flag.count(0)-1)

Fixed submission:
class UnionFind:
    def __init__(self, n):
        self.r = [-1 for i in range(n)]
    
    def root(self, x):
        if self.r[x] < 0:
            return x
        self.r[x] = self.root(self.r[x])
        return self.r[x]
    
    def unite(self, x, y):
        x = self.root(x)
        y = self.root(y)
        if x == y:
            return False
        if self.r[x] < self.r[y]:
            temp = x
            x = y
            y = temp
        self.r[x] += self.r[y]
        self.r[y] = x
        return True
    
    def size(self, x):
        return -self.r[self.root(x)]

n, m = map(int, input().split())
UF = UnionFind(n)
for i in range(m):
    a, b = map(lambda x: int(x)-1, input().split())
    UF.unite(a, b)

ans = 0
for i in UF.r:
    if i < 0:
        ans += 1

print(ans-1)
Buggy python submission (verdict: Time Limit Exceeded):
h, w, m = map(int, input().split())
table = [[0 for i in range(w)] for i in range(h)]
sum_rows = [0 for i in range(h)]
sum_cols = [0 for i in range(w)]
for i in range(m):
    h_, w_ = map(int, input().split())
    table[h_-1][w_-1] = 1
    sum_rows[h_-1] += 1
    sum_cols[w_-1] += 1

m_rows = [i for i, val in enumerate(sum_rows) if val == max(sum_rows)]
m_cols = [i for i, val in enumerate(sum_cols) if val == max(sum_cols)]
flag = 0
for i in m_rows:
    for j in m_cols:
        if table[i][j] == 0:
            flag = 1
if flag:
    print(max(sum_cols)+max(sum_rows))
else:
    print(max(sum_cols)+max(sum_rows)-1)

Fixed submission:
h, w, m = map(int, input().split())
table = []
sum_rows = [0 for i in range(h)]
sum_cols = [0 for i in range(w)]
for i in range(m):
    h_, w_ = map(int, input().split())
    table.append((h_, w_))
    sum_rows[h_-1] += 1
    sum_cols[w_-1] += 1

r = max(sum_rows)
c = max(sum_cols)
ans_ = (r + c)
count = 0
for i in range(m):
    if ans_ == (sum_rows[table[i][0]-1]+sum_cols[table[i][1]-1]):
        count += 1

if count == (sum_rows.count(r) * sum_cols.count(c)):
    print(ans_-1)
else:
    print(ans_)
Buggy python submission (verdict: Runtime Error):
n = int(input())
num = list(map(int, input().split()))
q = int(input())
change = [0 for i in range(q)]
for i in range(q):
    change[i] = list(map(int, input().split()))

dic = {}
for i in num:
    if i in dic:
        dic[i] += 1
    else:
        dic[i] = 1
ans = 0
for i, j in enumerate(dic):
    ans += j*dic[j]

for i in range(q):
    ans += dic[change[i][0]] * (change[i][1] - change[i][0])
    if change[i][0] in dic:
        if change[i][1] in dic:
            dic[change[i][1]] += dic.pop(change[i][0])
        else:
            dic[change[i][1]] = dic.pop(change[i][0])
    print(ans)

Fixed submission:
n = int(input())
num = list(map(int, input().split()))
q = int(input())
change = [0 for i in range(q)]
for i in range(q):
    change[i] = list(map(int, input().split()))

dic = {}
for i in num:
    if i in dic:
        dic[i] += 1
    else:
        dic[i] = 1
ans = 0
for i, j in enumerate(dic):
    ans += j*dic[j]

for i in range(q):
    if change[i][0] in dic:
        ans += dic[change[i][0]] * (change[i][1] - change[i][0])
        if change[i][1] in dic:
            dic[change[i][1]] += dic.pop(change[i][0])
        else:
            dic[change[i][1]] = dic.pop(change[i][0])
    print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
num = list(map(int, input().split()))
q = int(input())
change = [0 for i in range(q)]
for i in range(q):
    change[i] = list(map(int, input().split()))

dic = {}
for i in num:
    if i in dic:
        dic[i] += 1
    else:
        dic[i] = 1

for i in range(len(change)):
    ans = 0
    if change[i][0] in dic:
        if change[i][1] in dic:
            dic[change[i][1]] += dic.pop(change[i][0])
        else:
            dic[change[i][1]] = dic.pop(change[i][0])
    for i, j in enumerate(dic):
        ans += j*dic[j]
    print(ans)

Fixed submission:
n = int(input())
num = list(map(int, input().split()))
q = int(input())
change = [0 for i in range(q)]
for i in range(q):
    change[i] = list(map(int, input().split()))

dic = {}
for i in num:
    if i in dic:
        dic[i] += 1
    else:
        dic[i] = 1
ans = 0
for i, j in enumerate(dic):
    ans += j*dic[j]

for i in range(q):
    if change[i][0] in dic:
        ans += dic[change[i][0]] * (change[i][1] - change[i][0])
        if change[i][1] in dic:
            dic[change[i][1]] += dic.pop(change[i][0])
        else:
            dic[change[i][1]] = dic.pop(change[i][0])
    print(ans)
Buggy python submission (verdict: Runtime Error):
#include<iostream>
using namespace std;

int main(){
    long long n, k;
    cin >> n >> k;
    long long ans = 0;

    for (int i = k; i <= n+1; ++i){
        ans += i * (n - i + 1) + 1;
        ans %= 1000000007;
    }
    cout << ans << endl;
}

Fixed submission:
n, k = map(int, input().split())

ans = 0
for i in range(k, n+2):
    ans += i * (n - i + 1) + 1
    ans %= 1000000007

print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n, x, y = map(int, input().split())

lis = [0]*(n-1)
for i in range(n):
    for j in range(i+1, n):
        a = j-i
        if a == 1:
            dist = 1
        else:
            b = min(abs(x-1-i), abs(y-1-i)) + 1 + min(abs(y-1-j), abs(x-1-j))
            dist = min(a, b)
        lis[dist-1] += 1

for i in lis:
    print(i)

Fixed submission:
n, x, y = map(int, input().split())

lis = [0]*(n-1)
for i in range(n):
    disxi = min(abs(x-1-i), abs(y-1-i))
    for j in range(i+1, n):
        a = j-i
        if a == 1:
            dist = 1
        else:
            b = disxi + 1 + min(abs(y-1-j), abs(x-1-j))
            dist = min(a, b)
        lis[dist-1] += 1

for i in lis:
    print(i)

Buggy python submission (verdict: Time Limit Exceeded):
n, x, y = map(int, input().split())

lis = [0]*(n-1)
for i in range(n):
    for j in range(i+1, n):
        a = j-i
        b = min(abs(x-1-i), abs(y-1-i)) + 1 + min(abs(y-1-j), abs(x-1-j))
        dist = min(a, b)
        lis[dist-1] += 1

for i in lis:
    print(i)

Fixed submission:
n, x, y = map(int, input().split())

lis = [0]*(n-1)
for i in range(n):
    disxi = min(abs(x-1-i), abs(y-1-i))
    for j in range(i+1, n):
        a = j-i
        if a == 1:
            dist = 1
        else:
            b = disxi + 1 + min(abs(y-1-j), abs(x-1-j))
            dist = min(a, b)
        lis[dist-1] += 1

for i in lis:
    print(i)
Buggy python submission (verdict: Time Limit Exceeded):
s = input()
q = int(input())

count = 0
for i in range(q):
    q_i = input()
    if len(q_i) == 1:
        count += 1
    else:
        lis = [i for i in q_i.split()]
        x = count
        x += int(lis[1])
        if x % 2 == 0:
            s += lis[2]
        else:
            s = lis[2] + s

if count % 2 == 1:
    ans = ""
    for i in range(len(s)):
        ans += s[-i-1]
else:
    ans = s
print(ans)

Fixed submission:
s = input()
q = int(input())
 
count = 0
s_f = ""
for i in range(q):
    q_i = input()
    if len(q_i) == 1:
        count += 1
    else:
        lis = [i for i in q_i.split()]
        x = count
        x += int(lis[1])
        if x % 2 == 0:
            s += lis[2]
        else:
            s_f += lis[2]

ans = ""
if count % 2 == 1:
    for i in range(len(s)):
        ans += s[-i-1]
    ans += s_f
else:
    s_f_ = ""
    for i in range(len(s_f)):
        s_f_ += s_f[-i-1]
    ans = s_f_ + s
print(ans)
Buggy python submission (verdict: Runtime Error):
#include<iostream>
#include<string>
using namespace std;

int main(){
    int i;
    string s;
    cin >> i;
    cin >> s;
    if(i < 32000){
        cout << "red" << endl;
    }
    else{
        cout << s << endl;
    }
}

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

if a < 3200:
  print("red")
else:
  print(s)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
list = []
for i in range(n):
    list += [int(input())]

max_ = max(list)
for i in range(n):
    a = list[i]
    if a == max_:
        del list[i]
        ans = max(list)
        print(ans)
        list.insert(i,a)
    else:
        print(max_)


Fixed submission:
n = int(input())
list = []
for i in range(n):
    list += [int(input())]

max_ = max(list)
for i in range(n):
    a = list[i]
    if a == max_:
        del list[i]
        ans = max(list)
        print(ans)
        list.insert(i,a)
        if ans == max_:
            for j in range(n-i-1):
                print(max_)
            break
    else:
        print(max_)

Buggy python submission (verdict: Runtime Error):
n = int(input())
list = []
for i in range(n):
    list += [int(input())]

max = max(list)
for i in range(n):
    a = list[i]
    if a == max:
        del list[i]
        print(max(list))
        list.insert(i,a)
    else:
        print(max)

Fixed submission:
n = int(input())
list = []
for i in range(n):
    list += [int(input())]

max_ = max(list)
for i in range(n):
    a = list[i]
    if a == max_:
        del list[i]
        ans = max(list)
        print(ans)
        list.insert(i,a)
        if ans == max_:
            for j in range(n-i-1):
                print(max_)
            break
    else:
        print(max_)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
list = []
for i in range(n):
    list += [int(input())]

for i in range(n):
    a = list[i]
    del list[i]
    ans = max(list)
    list.insert(i,a)
    print(ans)

Fixed submission:
n = int(input())
list = []
for i in range(n):
    list += [int(input())]

max_ = max(list)
for i in range(n):
    a = list[i]
    if a == max_:
        del list[i]
        ans = max(list)
        print(ans)
        list.insert(i,a)
        if ans == max_:
            for j in range(n-i-1):
                print(max_)
            break
    else:
        print(max_)
Buggy python submission (verdict: Runtime Error):
a,b,c,d = map(int,input().split())

e = int(b // c)
f = int(a // c)
if f == int(a / c):
    g = e - f + 1
else:
    g = e - f

h = int(b // d)
i = int(a // d)
if i == int(a / d):
    j = h - i + 1
else:
    j = h - i

import fractions

cd = c*d / fractions.gcd(c,d)

k = int(b // cd)
l = int(a // cd)
if l == int(a / cd):
    m = k - l + 1
else:
    m = k - l

ans = (b-a) + 1 - (g + j - m)
print(int(ans))


Fixed submission:
s = str(input())

l = []
for x in s:
    l += [x]

truf = True
for x in range(3):
    if l[x] == l[x+1]:
        truf = False

if truf:
    print('Good')
else:
    print('Bad')
Buggy python submission (verdict: Runtime Error):
x,a = map(int,input().split)

if x >= a:
  print('10')
else:
  print('0')

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

if x >= a:
  print('10')
else:
  print('0')
Buggy python submission (verdict: Runtime Error):
n = int(input())
lis = []
for i in range(n):
    lis.append(int(input()))

lis.sort()

mid = lis[n-1]
front, back = [], []
flag = 1
for i in range((n-1)//2):
    if flag:
        front.append(lis[i])
        back.append(lis[i + 1])
        flag = 0
    else:
        front.append(lis[n - i - 1])
        back.append(lis[n - i - 2])
        flag = 1
if (n-1) % 2 == 1:
    front.append(lis[n//2-1])
ans_M = mid - front[0] + mid - back[0]
for i in range(1, len(front)):
    ans_M += abs(front[i] - front[i-1])
for i in range(1, len(back)):
    ans_M += abs(back[i] - back[i-1])

mid = lis[0]
front, back = [], []
flag = 1
for i in range((n-1)//2):
    if flag:
        front.append(lis[n - i - 1])
        back.append(lis[n - i - 2])
        flag = 0
    else:
        front.append(lis[i])
        back.append(lis[i + 1])
        flag = 1
if (n-1) % 2 == 1:
    front.append(lis[n//2-1])
ans_m = front[0] - mid + back[0] - mid
for i in range(1, len(front)):
    ans_m += abs(front[i] - front[i-1])
for i in range(1, len(back)):
    ans_m += abs(back[i] - back[i-1])

print(max(ans_M, ans_m))

Fixed submission:
n = int(input())
lis = []
for i in range(n):
    lis.append(int(input()))

lis.sort()

mid = lis[n-1]
front, back = [], []
flag = 1
for i in range((n-1)//2):
    if flag:
        front.append(lis[i])
        back.append(lis[i + 1])
        flag = 0
    else:
        front.append(lis[n - i - 1])
        back.append(lis[n - i - 2])
        flag = 1
if (n-1) % 2 == 1:
    front.append(lis[n//2-1])

if n == 2:
    ans_M = mid - front[0]
else:
    ans_M = mid - front[0] + mid - back[0]

for i in range(1, len(front)):
    ans_M += abs(front[i] - front[i-1])
for i in range(1, len(back)):
    ans_M += abs(back[i] - back[i-1])

mid = lis[0]
front, back = [], []
flag = 1
for i in range((n-1)//2):
    if flag:
        front.append(lis[n - i - 1])
        back.append(lis[n - i - 2])
        flag = 0
    else:
        front.append(lis[i])
        back.append(lis[i + 1])
        flag = 1
if (n-1) % 2 == 1:
    front.append(lis[n//2-1])

if n == 2:
    ans_m = front[0] - mid
else:
    ans_m = front[0] - mid + back[0] - mid

for i in range(1, len(front)):
    ans_m += abs(front[i] - front[i-1])
for i in range(1, len(back)):
    ans_m += abs(back[i] - back[i-1])

print(max(ans_M, ans_m))
Buggy python submission (verdict: Runtime Error):
/*  ex5_3
    Graku   */
#include<stdio.h>

int main(void) {
    int height, width;
    scanf("%d %d", &height, &width);
    char matrix[height][width];
    for (int row = 0; row < height; ++row) {
        for (int col = 0; col < width; ++col) {
            scanf(" %c", &matrix[row][col]); //don't read "\n"
        }
    }

    int blank_rows[height], blank_cols[width]; //blank -> 0, not blank -> 1
    for (int row = 0; row < height; ++row) { //find blank rows
        int flag = 0;
        for (int col = 0; col < width; ++col) {
            if ('#' == matrix[row][col]) { //not blank
                flag = 1;
                break;
            }
        }
        blank_rows[row] = flag;
    }
    for (int col = 0; col < width; ++col) { //find blank columns
        int flag = 0;
        for (int row = 0; row < height; ++row) {
            if ('#' == matrix[row][col]) { //not blank
                flag = 1;
                break;
            }
        }
        blank_cols[col] = flag;
    }

    for (int row = 0; row < height; row++) {
        if (blank_rows[row]) { //if row is not blank
            for (int col = 0; col < width; ++col) {
                if (blank_cols[col]) { //if column is not blank
                    printf("%c", matrix[row][col]);
                }
            }
            printf("\n");
        }
    }

    return 0;
}

Fixed submission:
height, width = map(int, input().split())
lis = [[0 for i in range(width)] for i in range(height)]
for i in range(height):
    lis[i] = input()

blank_rows = []
for row in range(height):
    if not "#" in lis[row]:
        blank_rows.append(row)

blank_cols = []
for col in range(width):
    flag = 1
    for row in range(height):
        if "#" == lis[row][col]:
            flag = 0
            break
    if flag:
        blank_cols.append(col)

for row in range(height):
    out = ""
    if not row in blank_rows:
        for col in range(width):
            if not col in blank_cols:
                out += lis[row][col]
    if not out == "":
	    print(out)
Buggy python submission (verdict: Runtime Error):
a, b, x = map( int, input())

print(b//x - a//x + 1)

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

print( b//x - (a-1)//x)
Buggy python submission (verdict: Time Limit Exceeded):
import math
N = int(input())
cnt = 0
for a in range(1,N):
  for b in range(1,math.ceil(N/a)):
    c = N - a * b
    if c <= 0:
      break
    else:
      # print("a,b :",end='')
      # print(a,b)
      # print("c :" + str(c))
      cnt += 1
print(cnt)


Fixed submission:
import math
N = int(input())
cnt = 0
for a in range(1,N):
  for b in range(a,math.ceil(N/a)):
    c = N - a * b
    if c <= 0:
      break
    else:
      if a == b:
        cnt += 1
      else :
        cnt += 2
print(cnt)
Buggy python submission (verdict: Runtime Error):

def cal(N):
  for n in range(3,N+1):
    left = N - n
    right = n
    if left < 6:
      return 1
    else:
      return 1 + cal(left)

    if right < 6:
      return 1
    else:
      return 1 + cal(right)
    
    
S = int(input())

if S < 3:
  print(0)
  exit()
else:
  ans = cal(S)
  print((1+ans)%dekai())


Fixed submission:
N = int(input())
mod = 10**9+7
ans = pow(10,N,mod) + pow(8,N,mod) - pow(9,N,mod) - pow(9,N,mod)
print(ans%mod)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
A = list(map(int, input().split()))


def mod10_9_7(num):
    return num % (10**9+7)


ans = 0
for i in range(N-1):
    for j in range(i, (N)):
        if i != j:
            ii = A[i]
            jj = A[j]
            if ii > 10 ** 5 or jj > 10 ** 5:
                ii = mod10_9_7(ii)
                jj = mod10_9_7(jj)
            ans += ii*jj

print(mod10_9_7(ans))

Fixed submission:
N = int(input())
A = list(map(int, input().split()))


def mod10_9_7(num):
    return num % (10**9+7)


seki = A[-1]

ans = 0
for i in range(N-2, -1, -1):
    ans += A[i] * seki
    seki += A[i]
print(mod10_9_7(ans))
Buggy python submission (verdict: Time Limit Exceeded):
K = int(input())
a = 7
cnt = 1
for k in range(K):
    if a % K == 0:
        print(cnt)
        exit()
    else:
        cnt += 1
        a = a * 10 + 7
else:
    print("-1")


Fixed submission:
K = int(input())
a = 7 % K
cnt = 1
for k in range(K):
    if a % K == 0:
        print(cnt)
        exit()
    else:
        cnt += 1
        a = (a * 10 + 7) % K
else:
    print("-1")