Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
from decimal import *

import numpy as np

import math

if __name__ == '__main__':
    n = int(input())
    b, c = map(int, input().split())
    list =[]
    min = 110
    d = [int(i) for i in input().split()]

    for i in d:
        a =Decimal(i)*Decimal(0.006)
        list.append(abs(c-a))
        if min > abs(c-a):
            min=abs(c-a)
    print(list.index(min)+1)



Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *

import numpy as np

import math

if __name__ == '__main__':
    n = int(input())
    b, c = map(int, input().split())
    list = []
    min = 10000000000
    d = [int(i) for i in input().split()]
    c = c * 1000

    for i in d:
        a = b *1000 - i * 6
        diff = 0
        if (a > 0 and c > 0) or (a < 0 and c < 0):
            diff = abs(c - a)
        else:
            diff = abs( a) +abs(c)
        list.append(diff)
        if min > diff:
            min = diff
    print(list.index(min) + 1)

Buggy python submission (verdict: Runtime Error):
if __name__ == '__main__':
    n = int(input())
    b, c = map(int, input().split())
    list =[]
    min = 110
    d = [int(i) for i in input().split()]

    for i in d:
        a =Decimal(i)*Decimal(0.006)
        list.append(abs(c-a))
        if min > abs(c-a):
            min=abs(c-a)
    print(list.index(min)+1)



Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *

import numpy as np

import math

if __name__ == '__main__':
    n = int(input())
    b, c = map(int, input().split())
    list = []
    min = 10000000000
    d = [int(i) for i in input().split()]
    c = c * 1000

    for i in d:
        a = b *1000 - i * 6
        diff = 0
        if (a > 0 and c > 0) or (a < 0 and c < 0):
            diff = abs(c - a)
        else:
            diff = abs( a) +abs(c)
        list.append(diff)
        if min > diff:
            min = diff
    print(list.index(min) + 1)
Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *

import numpy as np

import math

if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    x=a[2]-a[0]
    y=a[3]-a[1]

    print(str(a[2]-y)+" "+ str(a[3]+x)+" "+str(a[3]+x)+" "+str(a[1]+x)+" ")

Fixed submission:
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    x=a[2]-a[0]
    y=a[3]-a[1]

    print(str(a[2]-y)+" "+ str(a[3]+x)+" "+str(a[0]-y)+" "+str(a[1]+x)+" ")
Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a = [str(i) for i in input().split()]
    count = 0

    for i in range(4):
        if a[i] == "+":
            count +=1
        else:
            count -=1
    print(count)

Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a = [str(i) for i in input().split()]
    count = 0

    for i in range(4):
        if a[0][i] == "+":
            count +=1
        else:
            count -=1
    print(count)
Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a = [str(i) for i in input().split()]

    if a[0] >8 or a[1]>8:
        print("Yay!")
    else:
        print(":(")

Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a = [int(i) for i in input().split()]

    if a[0] >8 or a[1]>8:
        print(":(")
    else:
        print("Yay!")
Buggy python submission (verdict: Runtime Error):
if __name__ == '__main__':
    n =int(input())
    a = int(math.sqrt(n))

    max=1
    for i in range(2,a+1):
        now = i*i
        while now <= n:
            if max < now:
                max =now
            now = now*i
    print(max)

Fixed submission:
import math

if __name__ == '__main__':
    n =int(input())
    a = int(math.sqrt(n))

    max=1
    for i in range(2,a+1):
        now = i*i
        while now <= n:
            if max < now:
                max =now
            now = now*i
    print(max)

Buggy python submission (verdict: Runtime Error):
import math

if __name__ == '__main__':
    n =int(input())
    a = int(math.sqrt(n))

    print(a*

Fixed submission:
import math

if __name__ == '__main__':
    n =int(input())
    a = int(math.sqrt(n))

    max=1
    for i in range(2,a+1):
        now = i*i
        while now <= n:
            if max < now:
                max =now
            now = now*i
    print(max)

Buggy python submission (verdict: Runtime Error):
if __name__ == '__main__':
    n =int(input())
    a = int(math.sqrt(n))

    print(a*a)

Fixed submission:
import math

if __name__ == '__main__':
    n =int(input())
    a = int(math.sqrt(n))

    max=1
    for i in range(2,a+1):
        now = i*i
        while now <= n:
            if max < now:
                max =now
            now = now*i
    print(max)
Buggy python submission (verdict: Runtime Error):
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    n = int(input())
    a.sort()
    a[2] = a[2]*(2**n)
    print(su

Fixed submission:
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    n = int(input())
    a.sort()
    a[2] = a[2]*(2**n)
    print(sum(a))
Buggy python submission (verdict: Time Limit Exceeded):
if __name__ == '__main__':
    a, b,x = map(int, input().split())
    y = [i for i in range(a,b+1)]
    set1=set(y[:x])
    set2=set(y[len(y)-x:])
    sumSet = set1 | set2
    list = list(sumSet)
    list.sort()

    for i in list:
        print(i)


Fixed submission:
if __name__ == '__main__':
    a, b,x = map(int, input().split())
    set1=set([i for i in range(a,min(a+x,b))])
    set2=set([i for i in range(max(a,b-x+1),b+1)])
    sumSet = set1 | set2
    list = list(sumSet)
    list.sort()

    for i in list:
        print(i)

Buggy python submission (verdict: Time Limit Exceeded):
if __name__ == '__main__':
    a, b,x = map(int, input().split())
    y = [i for i in range(a,b+1)]
    set1=set(y[:x])
    set2=set(y[len(y)-x:])
    sumSet = set1 | set2
    list = list(sumSet)
    list.sort()

    for i in list:
        print(i)


Fixed submission:
if __name__ == '__main__':
    a, b,x = map(int, input().split())
    set1=set([i for i in range(a,min(a+x,b))])
    set2=set([i for i in range(max(a,b-x+1),b+1)])
    sumSet = set1 | set2
    list = list(sumSet)
    list.sort()

    for i in list:
        print(i)
Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *

import math
from functools import reduce

def gcd(*numbers):
    return reduce(math.gcd, numbers)

def gcd_list(numbers):
    return reduce(math.gcd, numbers)

if __name__ == '__main__':
    a,b = map(int,input().split())

    list = [0]*a

    for i in range(b):
        n,m=map(int, input().split())
        list[n-1]+=1
        list[m-1]+=1
    for i in list:
        print(i)

Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    a = [int(i) for i in input().split()]

    if a[2] >=a[0] and a[2] <=a[1]:
        print("Yes")
    else:
        print("No")

Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *

import math
from functools import reduce

def gcd(*numbers):
    return reduce(math.gcd, numbers)

def gcd_list(numbers):
    return reduce(math.gcd, numbers)

if __name__ == '__main__':
    a,b = map(int,input().split())

    list = [0]*a

    for i in range(b):
        n,m=map(int, input().split())
        list[n-1]+=1
        list[m-1]+=1
    for i in list:
        print(i)

Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    a = [int(i) for i in input().split()]

    if a[2] >=a[0] and a[2] <=a[1]:
        print("Yes")
    else:
        print("No")
Buggy python submission (verdict: Runtime Error):
if __name__ == '__main__':
    sys.setrecursionlimit(10 ** 6)
    b, c = map(int, input().split())
    num = b*3 -c
    if num == 0:
        num =1
    else:
        if num > b:
            num = b*3
        else:
            num = num *3
    print(num)




Fixed submission:
if __name__ == '__main__':
    b, c = map(int, input().split())
    num = b*3 -c

    count = 0
    for i in range (0,b+1):
        for j in range(0,b+1):
            if c-(i+j)<=b and c-(i+j) >=0:
                count+=1
    print(count)
Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    x = [int(i) for i in input().split()]
    a = x[0] // x[2]
    b = x[1] // x[1]
    
    print(b-a)

Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    x = [int(i) for i in input().split()]
    a = (x[0]-1) // x[2]
    b = x[1] // x[2]

    print(b-a)
Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque
from decimal import *

import numpy as np

import math

if __name__ == '__main__':
    n = int(input())
    s =input()
    t = input()
    count = 2*n

    for i in range(n):
        if t[i] == s[n-i-1]:
            count-=1
        else:
            break
    if s == t:
        print(n)
    else:
        print(count)

Fixed submission:
if __name__ == '__main__':
    n = int(input())
    s = input()
    t = input()
    count = 2 * n
    maxDiff = 0

    for i in range(0,n+1):
        diff = 0
        for j in range(i):
            if s[n - i :][j] == t[j]:
                diff+=1
            else:
                break
        if maxDiff < diff:
            maxDiff=diff
    print(count-maxDiff)
Buggy python submission (verdict: Runtime Error):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a =input()
    b=input()
    c=input()
    now = "A"
    for i in range(300):
        if now =="A":
            if len(a) >0:
                now = a.pop().upper()
            else:
                print("A")
                break
        if now =="B":
            if len(b) >0:
                now = b.pop().upper()
            else:
                print("B")
                break
        if now =="C":
            if len(c) >0:
                now = c.pop().upper()
            else:
                print("C")
                break

Fixed submission:
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a =input()
    b=input()
    c=input()
    now = "A"
    for i in range(300):
        if now =="A":
            if len(a) >0:
                now = a[0].upper()
                a=a[1:]
            else:
                print("A")
                break
        if now =="B":
            if len(b) >0:
                now = b[0].upper()
                b=b[1:]
            else:
                print("B")
                break
        if now =="C":
            if len(c) >0:
                now = c[0].upper()
                c=c[1:]
            else:
                print("C")
                break
Buggy python submission (verdict: Runtime Error):
import sympy

N = int(input())

output = 0

for i in range(1, N):
    count = sympy.divisor_count(i)
    output += count
    
print(output)

Fixed submission:
n = int(input())
ans = 0
for a in range(1, n):
  ans += (n - 1) // a
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
import math

N = int(input())

output = 0

for i in range(1, N):
    counter = 0
    for j in range(1, int(math.sqrt(i)+1)):
        if i % j == 0:
            counter += 1
    if int(math.sqrt(i)) == math.sqrt(i):
        counter -= 1
        counter *= 2
        counter += 1
    else :
        counter *= 2
    output += counter
    
print(output)

Fixed submission:
n = int(input())
ans = 0
for a in range(1, n):
  ans += (n - 1) // a
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
mod = 10**9 + 7
N = int(input())
array = [int(i) for i in input().split()]

output = 0
for i in range(N):
    for j in range(i+1, N):
        output += (array[i]%mod) * (array[j]%mod)
        
print(output%mod)

Fixed submission:
mod = 10**9 + 7
N = int(input())
array = [int(i) for i in input().split()]
array_2 = [0]

for a in array:
    array_2.append(array_2[-1]+a)
    
output = 0
for i in range(len(array)-1):
    output += array[i] * (array_2[-1] - array_2[i+1])
    
print(output%mod)

Buggy python submission (verdict: Time Limit Exceeded):
mod = 10**9 + 7
N = int(input())
array = [int(i) for i in input().split()]

output = 0
for i in range(N):
    for j in range(i+1, N):
        output += (array[i] * array[j])
        
print(output % mod)

Fixed submission:
mod = 10**9 + 7
N = int(input())
array = [int(i) for i in input().split()]
array_2 = [0]

for a in array:
    array_2.append(array_2[-1]+a)
    
output = 0
for i in range(len(array)-1):
    output += array[i] * (array_2[-1] - array_2[i+1])
    
print(output%mod)
Buggy python submission (verdict: Runtime Error):
N, X, T = [int(i) for i in input().spilt()]

ans = 0

if N % X == 0:
  ans = (N // X) * T
else :
  ans = ((N // X) + 1) * T 

print(ans)

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

q, r = divmod(N, X)

output = 0
if r > 0:
    output = (q+1) * T
else :
    output = q * T
    
print(output)
Buggy python submission (verdict: Time Limit Exceeded):
H, W, M = [int(i) for i in input().split()]

cnt_dict_h = {}
cnt_dict_w = {}
bomb_list = []

for i in range(M):
    h, w = [int(i)-1 for i in input().split()]
    bomb_list.append((h,w))
    cnt_dict_h.setdefault(h, 0)
    cnt_dict_h[h] += 1
    cnt_dict_w.setdefault(w, 0)
    cnt_dict_w[w] += 1

max_h_key_list = [kv[0] for kv in cnt_dict_h.items() if kv[1] == max(cnt_dict_h.values())]
max_w_key_list = [kv[0] for kv in cnt_dict_w.items() if kv[1] == max(cnt_dict_w.values())]
max_h = max(cnt_dict_h.values())
max_w = max(cnt_dict_w.values())

bomb_num = max_h + max_w - 1

flag = False

for h in max_h_key_list:
    for w in max_w_key_list:
        if (h, w) not in bomb_list:
            bomb_num = max_h + max_w
            break
        else :
            continue
        break
        
print(bomb_num)

Fixed submission:
H, W, M = [int(i) for i in input().split()]

sum_h = [0] * W
sum_w = [0] * H
bomb_list = set()

for _ in range(M):
    h, w = [int(i) for i in input().split()]
    h -= 1
    w -= 1
    bomb_list.add((h,w))
    sum_h[w] += 1
    sum_w[h] += 1

max_sum_h = max(sum_h)
max_sum_w = max(sum_w)
output = max_sum_h + max_sum_w - 1

max_bombs_h = [h for h in range(H) if sum_w[h] == max_sum_w]
max_bombs_w = [w for w in range(W) if sum_h[w] == max_sum_h]

for h in max_bombs_h:
    for w in max_bombs_w:
        if (h, w) not in bomb_list:
            output = max_sum_h + max_sum_w
            break
        else:
            continue
        break
        
print(output)

Buggy python submission (verdict: Time Limit Exceeded):
H, W, M = [int(i) for i in input().split()]

cnt_dict_h = {}
cnt_dict_w = {}
bomb_list = []

for i in range(M):
    h, w = [int(i)-1 for i in input().split()]
    bomb_list.append((h,w))
    cnt_dict_h.setdefault(h, 0)
    cnt_dict_h[h] += 1
    cnt_dict_w.setdefault(w, 0)
    cnt_dict_w[w] += 1

max_h_key_list = [kv for kv in cnt_dict_h.items() if kv[1] == max(cnt_dict_h.values())]
max_w_key_list = [kv for kv in cnt_dict_w.items() if kv[1] == max(cnt_dict_w.values())]

count_bombs = []
for h in max_h_key_list:
    for w in max_w_key_list:
        bomb__num = cnt_dict_h[h[0]]+cnt_dict_w[w[0]]
        if(h[0], w[0]) in bomb_list:
            count_bombs.append(bomb__num-1)
        else :
            count_bombs.append(bomb__num)
            
print(max(count_bombs))    

Fixed submission:
H, W, M = [int(i) for i in input().split()]

sum_h = [0] * W
sum_w = [0] * H
bomb_list = set()

for _ in range(M):
    h, w = [int(i) for i in input().split()]
    h -= 1
    w -= 1
    bomb_list.add((h,w))
    sum_h[w] += 1
    sum_w[h] += 1

max_sum_h = max(sum_h)
max_sum_w = max(sum_w)
output = max_sum_h + max_sum_w - 1

max_bombs_h = [h for h in range(H) if sum_w[h] == max_sum_w]
max_bombs_w = [w for w in range(W) if sum_h[w] == max_sum_h]

for h in max_bombs_h:
    for w in max_bombs_w:
        if (h, w) not in bomb_list:
            output = max_sum_h + max_sum_w
            break
        else:
            continue
        break
        
print(output)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
stones = [l for l in input()]

cnt = 0
for i in range(N//2):
    for j in range(N-1, i , -1):
        if stones[i] == 'W' and stones[j] == 'R':
            stones[i] = 'R'
            stones[j] = 'W'
            cnt += 1
            break
            
print(cnt)

Fixed submission:
N = int(input())
stones = [l for l in input()]

cnt = 0
memo = N-1
for i in range(N):
    for j in range(memo, i , -1):
        if stones[i] == 'R':
            break
        else :
            if stones[j] == 'R':
                stones[i] = 'R'
                stones[j] = 'W'
                cnt += 1
                break
    memo = j
    if memo == i:
        break
            
print(cnt)
Buggy python submission (verdict: Time Limit Exceeded):
N, K = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]

K_value = 1
for i in range(K):
    K_value *= a[i]
    
score_dict = {K-1:K_value}

for i in range(K, N):
    score_dict[i] = (score_dict[i-1] * a[i]) // a[i-K]
    if score_dict[i] > score_dict[i-1]:
        print('Yes')
    else:
        print('No')



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

for i in range(K, N):
    if a[i-K] < a[i]:
        print('Yes')
    else :
        print('No')

Buggy python submission (verdict: Time Limit Exceeded):
N, K = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a2 = [1]

for i in a:a2.append(a2[-1]*i)


score_dict = {K:a2[K]}

for i in range(K+1, N+1):
    score_dict[i] = a2[i]//a2[i-K]
    if score_dict[i] > score_dict[i-1]:
        print('Yes')
    else:
        print('No')

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

for i in range(K, N):
    if a[i-K] < a[i]:
        print('Yes')
    else :
        print('No')
Buggy python submission (verdict: Runtime Error):
N, M, K = [int(i) for i in input().split()]

As = [int(i) for i in input().split()]
Bs = [int(i) for i in input().split()]

cnt = 0
time = 0
while time <= K:
    if As and Bs:
        if As[0] > Bs[0]:
            p = Bs.pop(0)
        elif Bs[0] >= As[0]:
            p = As.pop(0)
        else :
    else :
        if As:
            p = As.pop(0)
        elif Bs:
            p = Bs.pop(0)
        else :
            break
    time += p
    if time > K:
        break
    cnt += 1
    
print(cnt)

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

array_A = [int(i) for i in input().split()]
array_B = [int(i) for i in input().split()]

array_A_2 = [0]
array_B_2 = [0]

for a in array_A:array_A_2.append(array_A_2[- 1]+a)
for b in array_B:array_B_2.append(array_B_2[- 1]+b)

output, j = 0, M

for i in range(N + 1):
    if array_A_2[i] > K:
        break
    while array_B_2[j] > K - array_A_2[i]:
        j -= 1
    output = max(output, i + j)

print(output)

Buggy python submission (verdict: Runtime Error):
N, M, K = [int(i) for i in input().split()]

As = [int(i) for i in input().split()]
Bs = [int(i) for i in input().split()]

cnt = 0
time = 0
while time <= K:
    cnt += 1
    if As and Bs:
        if As[0] > Bs[0]:
            p = Bs.pop(0)
        elif Bs[0] > As[0]:
            p = As.pop(0)
    else :
        if As:
            p = As.pop(0)
        elif Bs:
            p = Bs.pop(0)
        else :
            break
    time += p
    
print(cnt - 1)

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

array_A = [int(i) for i in input().split()]
array_B = [int(i) for i in input().split()]

array_A_2 = [0]
array_B_2 = [0]

for a in array_A:array_A_2.append(array_A_2[- 1]+a)
for b in array_B:array_B_2.append(array_B_2[- 1]+b)

output, j = 0, M

for i in range(N + 1):
    if array_A_2[i] > K:
        break
    while array_B_2[j] > K - array_A_2[i]:
        j -= 1
    output = max(output, i + j)

print(output)
Buggy python submission (verdict: Time Limit Exceeded):
from collections import Counter 
N = int(input())
numbers = [int(i) for i in input().split()]

c = Counter(numbers)

divisors = sorted(set(numbers))
target_numbers = sorted([k for k, v in c.items() if v == 1])

cnt = N - len(target_numbers)
for n in target_numbers:
    for d in divisors:
        if n == d:
            continue
        if n % d == 0:
            cnt += 1
            break
        if n /2 < d:
            break
            
print(N - cnt)

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

d = set()
s = set()

for n in numbers:
    if n in s: 
        d.add(n)
    else :
        s.add(n) 

M = max(s) 

X = [1 for _ in range(M+1)] 

for a in s:
    if a in d:
        X[a] = 0 
    for i in range(2*a, M+1, a): 
        X[i] = 0
    
output = 0

for n in numbers:
    if X[n] == 1:
        output += 1
print(output)
Buggy python submission (verdict: Runtime Error):
X = int(input())

numbers = dict()

for i in range(-101, 101):
    numbers.setdefault(i, i**5)


for i in range(-101, 101):
    for j in range(-101, 101):
        if numbers[i] - numbers[j] == X:
            output = [i, j]
            break
print(output[0], output[1])


Fixed submission:
X = int(input())

numbers = dict()

for i in range(-200, 200):
    numbers.setdefault(i, i**5)

for i in range(-200, 200):
    for j in range(-200, 200):
        if numbers[i] - numbers[j] == X:
            output = [i, j]
            break

print(output[0], output[1])