Harryxun/stf_run huggingface dataset:
import itertools

N,M = map(int,input().split())
value = [0] * N

for i in range(N):
  v = list(map(int,input().split()))
  abv = [i if i > 0 else i * - 1 for i in v]
  value[i] = v

ans = 0

for i in list(itertools.combinations(range(0,N),M)):
  a,b,c = value[i[0]],value[i[1]],value[i[2]]
  tmp = 0
  for j in range(3):
    t = a[j] + b[j] + c[j]
    if t < 0:
      t *= -1
    tmp += t
  ans = max(ans,tmp)
  
print(ans)

### FIXED CODE ###

import itertools

N,M = map(int,input().split())
value = [0] * N

for i in range(N):
  v = list(map(int,input().split()))
  abv = [i if i > 0 else i * - 1 for i in v]
  value[i] = v

ans = 0
totals = []

for i in range(0,2 ** 3):
  totals = []
  #print(bin(i))
  for v in range(N):
    tmp = 0
    for j in range(0,3):
      if (i >> j) & 1:
        tmp += value[v][j]
      else:
        tmp -= value[v][j]
    totals.append(tmp)
  #print(totals)
  totals = sorted(totals,reverse = True)

  t = 0
  for k in range(M):
    t += totals[k]
  ans = max(ans,t)
  
print(ans)
import sys
input=lambda: sys.stdin.readline().rstrip()
h,w=map(int,input().split())
ans=((h+1)//2+h//2)*(w//2)
if w%2==1:
  ans+=(h+1)//2
if h==1 or w==1:
  ans=1
peint(ans)

### FIXED CODE ###

import sys
input=lambda: sys.stdin.readline().rstrip()
h,w=map(int,input().split())
ans=((h+1)//2+h//2)*(w//2)
if w%2==1:
  ans+=(h+1)//2
if h==1 or w==1:
  ans=1
print(ans)
a=input()
b=0
if (len(a))%2==1:
  print("No")
else:
  for i in range(a/2):
    a[i]!=a[i+a/2]:
      b=b+1
  if b==0:
    print("Yes")
  else:
    print("No")

### FIXED CODE ###

c=input()
c=int(c)
a=input()
b=0
if c%2==1:
  print("No")
else:
  for i in range(int(c/2)):
    if a[i]!=a[i+int(c/2)]:
      b=b+1
  if b==0:
    print("Yes")
  else:
    print("No")
n = int(input())
r = list(map(int,input().split()))

for i in range(n):
    if i == 0:
        x = r[i]
    else:
        x = x * r[i]
    
    if x >= 10**19:
        x = -1
        break

if x > 10**18:
        x = -1
print(int(x))

### FIXED CODE ###

a = list(map(int,input().split()))

y = int(a[0]) * int(a[1])
print(y)
import sys
sys.setrecursionlimit(100001)
def input():
    return sys.stdin.readline()[:-1]
    
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())), reverse = True)
x = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]
dp = [0 for i in range(N+1)]
for i in range(2, N+1):
    for a in A:
        if i >= x[a] and dp[i-x[a]] + 1 > dp[i]:
            dp[i] = dp[i-x[a]] + 1
K = N
ans = ''
while K > 0:
    for a in A:
        if dp[K] == dp[K-x[a]] + 1:
            ans += str(a)
            K -= x[a]
            break
print(ans)

### FIXED CODE ###

N, M = map(int, input().split())
A = sorted(list(map(int, input().split())), reverse = True)
x = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]
dp = [0 for i in range(N+1)]
INF = float('inf')
for i in range(1, N+1):
    t = -INF
    for a in A:
        if i >= x[a]:
            t = max(dp[i-x[a]] + 1, t)
    dp[i] = t

K = N
k = dp[N]
ans = ""
while k > 0:
    for a in A:
        xa = x[a]
        if K >= xa and k == dp[K-xa] + 1:
            ans += str(a)
            K -= xa
            k -= 1
            break
print(ans)
n = int(input())
count = 0
for i in range(n):
    x = int(input())
    if (x < 2):
        break
    if (x == 2):
        count += 1
    else:
        while (j * j <= x):
            if (x % j == 0):
                break
            else:
                count += 1
            j = j + 1
print(count)
 

### FIXED CODE ###

n = int(input())
count = 0
for i in range(n):
    x = int(input())
    if (x == 2):
        count += 1
    elif (x % 2 == 0):
        continue
    else:
        if (pow(2, x - 1, x) == 1):
            count += 1
print(count)
#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long u64;

const int maxn = 100000 + 10;
u64 n, m, p, fac[maxn];

inline u64 Fast_Pow(u64 x, u64 k) {
    u64 ans = 1;
    while(k) {
        if( k&1 ) ans = ans * x % p;
        k >>= 1, x = x * x % p;
    }
    return ans;
}

u64 C(u64 k, u64 b) {
    if( k<b )  return 0;
    return fac[k] * Fast_Pow(fac[b] % p, p-2) % p * Fast_Pow(fac[k-b] % p, p-2) % p;
}

u64 Lucas(u64 k, u64 b) {
    if( !b )  return 1;
    return C(k%p, b%p) * Lucas(k/p, b/p) % p;
}

int main(int argc, char const *argv[])
{
    int t;  scanf("%d", &t);
    while( t-- ) {
        fac[0] = 1;
        scanf("%lld%lld%lld", &n, &m, &p);
        for(int i=1; i<=p; ++i)
            fac[i] = fac[i-1] * i % p;
        printf("%lld\n", Lucas(n+m, m));
    }
    return 0;
}

### FIXED CODE ###

print(int(input())**2)
n = int(input())
A=[]
for i in range(n):
  A.append(list(input().split()))
 
ans=0
for a in A:
    if a[1] =="JPY":
        ans += float(a[1])
    else:
        ans += float(a[0]) * 380000.0
print(ans)

### FIXED CODE ###

n = int(input())
A=[]
for i in range(n):
  A.append(list(input().split()))
 
ans=0
for a in A:
    if a[1] =="JPY":
        ans += float(a[0])
    else:
        ans += float(a[0]) * 380000.0
print(ans)
x=raw_input()
print(x**3)

### FIXED CODE ###

x=int(input())
print(x**3)
def f(x):
    if x == 0:
        return 0
    return x + f(x - 1)

a, b = map(int, input().split())
x = b - a
ans = f(x) - b

print(ans)

### FIXED CODE ###

a, b = map(int, input().split())
n = b - a

ans = 0
for i in range(1, n + 1):
    ans += i
    
print(ans - b)
N,A,B = map(int, input().split())
S = input().split()
s=[]
for i in S:
    s.append(i)
list=[]
H = list.count('b')
for i in range(N):
  if s[i] == 'c'
    print('No')
  elif s[i] =='a' and len(list) <= A+B:
    print('Yes')
    list.append(a)
  elif s[i] =='a':
    print('No')
  elif len(list) <= A+B and H <= B:
    print('Yes')
  else:
    print('No')

### FIXED CODE ###

N, A, B = map(int, input().split())
S = str(input())
 
total = 0
kaigai = 0
 
for i in range(0, len(S)):
    if S[i] == 'a':
        if total < A+B:
            print('Yes')
            total += 1
        else:
            print('No')
    elif S[i] == 'b':
        if total < A+B and kaigai <B:
            print('Yes')
            total += 1
            kaigai += 1
        else:
            print('No')
    else:
        print('No')
N = int(input())
S = input()
_min = -1
for i in range(N):
    left_str = S[:i]
    right_str = S[i+1:]
    left = count('W', left_str)
    right = count('E', right_str)
    total = left + right
    if _min == -1:
        _min = total
    elif total < _min:
        _min = total
print(_min)
def count(item, str1):
    counter = 0
    for c in str1:
        if c == item:
            counter += 1
    return counter
        

### FIXED CODE ###

N = int(input())
S = input()
w_count = 0
e_count = 0
w_counts = [0 for _ in range(N)]
e_counts = [0 for _ in range(N)]
for i in range(N):
    if S[i] == 'W':
        w_count += 1
    w_counts[i] = w_count
for i in range(N-1, -1, -1):
    if S[i] == 'E':
        e_count += 1
    e_counts[i] = e_count
_min = -1
for i in range(N):
    total = w_counts[i] + e_counts[i]
    if _min == -1:
        _min = total
    if _min > total:
        _min = total
print(_min-1)
N=int(input())

for h in range(1,N+1):
    num=0
    for i in range(1,N):
        for j in range(1,N):
            for k in range(1,N):
                if i**2+j**2+k**2+i*j+j*k+k*i==h:
                    num+=1
    print(num)


### FIXED CODE ###

L,R,d=list(map(int,input().split()))
I=R-L+1
if L%d==0 and R%d==0:
    I=R-L
    print((I//d)+1)
else:
    print(I//d)
#D
from collections import deque
#import bisect
#import math
#import heapq
#import sys
#input = sys.stdin.readline

#inf = float("inf")
#mod = 10**9 + 7
#mod = 998244353

#list(map(int,input().split()))

N = int(input())
AB = [list(map(int,input().split())) for i in range(N-1)]
K = [0]*N
for ab in AB:
    a,b = ab
    K[a-1]+=1
    K[b-1]+=1
k = max(K)
print(k)

C = [0]*N
D = deque(AB)
flag = 0
visited = [-1]*N
#print(D)
while D:
    a,b = D.popleft()
    if visited[a-1] == -1 and visited[b-1] == -1:
        if flag == 0:
            flag = 1
            visited[a-1] = 0
            visited[b-1] = 0
            print(1)
            C[a-1] = 1
            C[b-1] = 1
        else:
            D.append([a,b])
    else:
        if visited[b-1] == -1:
            if C[a-1] == k:
                print(1)
                C[a-1] = 1
                C[b-1] = 1
            else:
                print(C[a-1]+1)
                C[a-1]+=1
                C[b-1] = C[a-1]
            visited[b-1] = 0
        else:
            visite[a-1] = 0
            if C[b-1] == k:
                print(1)
                C[a-1] = 1
                C[b-1] = 1
            else:
                print(C[b-1]+1)
                C[b-1]+=1
                C[a-1] = C[b-1]
        

            




### FIXED CODE ###

#D
from collections import deque
#import bisect
#import math
#import heapq
#import sys
#input = sys.stdin.readline

#inf = float("inf")
#mod = 10**9 + 7
#mod = 998244353

#list(map(int,input().split()))

N = int(input())
AB = []
for i in range(N-1):
    a,b = map(int,input().split())
    AB.append([a,b,i])

K = [0]*N
for ab in AB:
    a,b,i = ab
    K[a-1]+=1
    K[b-1]+=1
k = max(K)
print(k)
AB.sort()
C = [0]*N
D = deque(AB)
flag = 0
visited = [-1]*N
ans = [0]*(N-1)
while D:
    a,b,i = D.popleft()
    if visited[a-1] == -1 and visited[b-1] == -1:
        if flag == 0:
            flag = 1
            visited[a-1] = 0
            visited[b-1] = 0
            ans[i] = 1
            C[a-1] = 1
            C[b-1] = 1
        else:
            D.append([a,b,i])
    else:
        if visited[b-1] == -1:
            if C[a-1] == k:
                ans[i] = 1
                C[a-1] = 1
                C[b-1] = 1
            else:
                ans[i] = C[a-1]+1
                C[a-1]+=1
                C[b-1] = C[a-1]
            visited[b-1] = 0
        else:
            visited[a-1] = 0
            if C[b-1] == k:
                ans[i] = 1
                C[a-1] = 1
                C[b-1] = 1
            else:
                ans[i] = C[b-1]+1
                C[b-1]+=1
                C[a-1] = C[b-1]
                
for a in ans:
    print(a)
N, K = map(int, input().split())
Dices = list(map(int, input().split()))
Que = []
Eyes = {}
for i in range(K):
    Que.append(Dices[i])
Eyes[K]=sum(Que)
for i in range(K+1, N):
    Que.pop(0)
    Que.append(Dices[i])
    Eyes[i] = Eyes[i-1]-Que[0]+Que[-1]
a = 0
b = 0
for k, v in Eyes.items():
    if v > a:
        a = v
        b = k
ans = 0
for i in range(k-K+1, k+1):
    ans += (Dices[i]+1)/2
print(ans)

### FIXED CODE ###

N, K = map(int, input().split())
dices = list(map(int, input().split()))

exv = [(e+1)/2 for e in dices]
temp = sum(exv[0:K])
result = temp
for i in range(N-K):
    temp -= exv[i]
    temp += exv[i+K]
    if temp > result:
        result = temp
print(result)
from collections import deque
 
def main():
    h, w = map(int, input().split())
    G = [("#",)*(w+2)]+[("#",)+tuple(input())+("#",) for i in range(h)]+[("#",)*(w+2)]
    dy, dx = [-1, 1, 0, 0], [0, 0, -1, 1]
    dist = [[-1 for j in range(w+2)] for i in range(h+2)]
    que = deque()
    
    for i in range(1, h+1):
        for j in range(1, w+1):
            if G[i][j] == "#":
                dist[i][j] = 0
                que.append((i, j))
    ans = 0
    while (len(que) != 0):
        y, x = que[0][0], que[0][1]
        que.popleft()
 
        for i in range(4):
            ny, nx = y+dy[i], x+dx[i]
            if G[ny][nx] == "#":
                continue
            if dist[ny][nx] == -1:
                dist[ny][nx] = dist[y][x] + 1
                que.append((ny, nx))
                ans = max(ans, dist[ny][nx])
    print(ans)
if __name__ == "__main__":
    main()
from collections import deque

def main():
    h, w = map(int, input().split())
    G = [("#",)*(w+2)]+[("#",)+tuple(input())+("#",) for i in range(h)]+[("#",)*(w+2)]
    dy, dx = [-1, 1, 0, 0], [0, 0, -1, 1]
    dist = [[-1 for j in range(w+2)] for i in range(h+2)]
    que = deque()
    
    for i in range(1, h+1):
        for j in range(1, w+1):
            if G[i][j] == "#":
                dist[i][j] = 0
                que.append((i, j))
    ans = 0
    while (len(que) != 0):
        y, x = que[0][0], que[0][1]
        que.popleft()

        for i in range(4):
            ny, nx = y+dy[i], x+dx[i]
            if G[ny][nx] == "#":
                continue
            if dist[ny][nx] == -1:
                dist[ny][nx] = dist[y][x] + 1
                que.append((ny, nx))
                ans = max(ans, dist[ny][nx])
    print(ans)
if __name__ == "__main__":
    main()
提出情報

### FIXED CODE ###

from collections import deque

def main():
    h, w = map(int, input().split())
    G = [["#"]*(w+2)]+[["#"]+list(input())+["#"] for i in range(h)]+[["#"]*(w+2)]
    dy, dx = [-1, 1, 0, 0], [0, 0, -1, 1]
    dist = [[-1 for j in range(w+2)] for i in range(h+2)]
    que = deque()
    
    for i in range(1, h+1):
        for j in range(1, w+1):
            if G[i][j] == "#":
                dist[i][j] = 0
                que.append((i, j))
    
    while (len(que) != 0):
        y, x = que[0][0], que[0][1]
        que.popleft()

        for i in range(4):
            ny, nx = y+dy[i], x+dx[i]
            if G[ny][nx] == "#":
                continue
            if dist[ny][nx] == -1:
                dist[ny][nx] = dist[y][x] + 1
                que.append((ny, nx))
    
    ans = 0
    for i in range(1, h + 1):
        for j in range(1, w + 1):
            ans = max(ans, dist[i][j])
    print(ans)
if __name__ == "__main__":
    main()
s = raw_input()
# a, b = s.split(' ')
# a, b = int(a), int(b)
n = 0

def mul(s, n):
    if len(s) < 3:
        return 0
    for i in range(len(s) - 2):
        str = s[i:(i+3)]
        if str == "ABC":
            n = n + 1
            print(s[:i] + "BCA"+ s[i+3:])
            return mul(s[:i] + "BCA"+ s[i+3:], n)
            # _str[i:i+3] = "BCA"+ _str[i+3:]
    return n
print(mul(s,n))

### FIXED CODE ###

def test(s):

	res = 0
	aAdd = 0
	last = ''
	tmp = ''
	for i in xrange(len(s)):
		if tmp and tmp > i:
			continue
		if s[i] == 'A':
			aAdd += 1
		elif s[i:i+2] == 'BC':
			# print aAdd
			res = res + aAdd
			tmp = i + 2
		else:
			aAdd = 0
			last = s[i]


	return res
s=raw_input()
print test(s)
import sys
sys.setrecursionlimit(10*9)

def dfs(now):
    for to,dis in G[now]:
        if color[to] == -1:
            color[to] = (color[now] + dis) % 2
            dfs(to)

N = int(input())
G = [[] for _ in range(N)]
color = [-1] * N
color[0] = 0 #偶数=0

for i in range(N-1):
    a,b,c = map(int,input().split())
    a -= 1
    b -= 1
    G[a].append([b,c%2])
    G[b].append([a,c%2])

#print(G)    
dfs(0)
print(*color,sep="\n")

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**9)

def dfs(now):
    for to,dis in G[now]:
        if color[to] == -1:
            color[to] = (color[now] + dis) % 2
            dfs(to)

N = int(input())
G = [[] for _ in range(N)]
color = [-1] * N
color[0] = 0 #偶数=0

for i in range(N-1):
    a,b,c = map(int,input().split())
    a -= 1
    b -= 1
    G[a].append([b,c%2])
    G[b].append([a,c%2])

#print(G)    
dfs(0)
print(*color,sep="\n")
n = int(input())

sum_ = 0
for i in range(1, n+1):
  if i%15 !=0:
    sum += i
    
print(sum_)

### FIXED CODE ###

n = int(input())

sum_ = 0
for i in range(1, n+1):
  if i%15 !=0 and i%3 !=0 and i%5 !=0:
    sum_ += i
    
print(sum_)
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

import operator

N,H,W = map(int,readline().split())
RCA = [int(x) for x in read().split()]
it = iter(RCA)
RCA = sorted(zip(it,it,it),key=operator.itemgetter(2),reverse=True)

root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)

def find_root(x):
    y = root[x]
    if x == y:
        return y
    z = find_root(y)
    root[x] = z
    return z

def merge(x,y):
    x,y = find_root(x),find_root(y)
    sx,sy = size[x],size[y]
    if sx < sy:
        sx,sy = sy,sx
        x,y = y,x
    root[y] = x
    no_cycle[x] = no_cycle[x] and no_cycle[y]

answer = 0
for R,C,A in RCA:
    x,y = R-1,H+C-1
    rx,ry = find_root(x),find_root(y)
    if rx == ry:
        if not no_cycle[rx]:
            continue
        no_cycle[rx] = False
    else:
        if (not no_cycle[rx]) and (not no_cycle[ry]):
            continue
        merge(rx,ry)
    answer += A

print(answer)

### FIXED CODE ###

import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)

N,H,W = map(int,readline().split())
RCA = [tuple(int(x) for x in line.split()) for line in readlines()]

RCA.sort(key = lambda x: -x[2])

RCA

root = list(range(H+W))
size = [0] * (H+W)
no_cycle = [True] * (H+W)

def find_root(x):
    y = root[x]
    if x == y:
        return y
    z = find_root(y)
    root[x] = z
    return z

def merge(x,y):
    x,y = find_root(x),find_root(y)
    sx,sy = size[x],size[y]
    if sx < sy:
        sx,sy = sy,sx
        x,y = y,x
    root[y] = x
    no_cycle[x] = no_cycle[x] and no_cycle[y]

answer = 0
for R,C,A in RCA:
    x,y = R-1,H+C-1
    rx,ry = find_root(x),find_root(y)
    if rx == ry:
        if not no_cycle[rx]:
            continue
        no_cycle[rx] = False
    else:
        if (not no_cycle[rx]) and (not no_cycle[ry]):
            continue
        merge(rx,ry)
    answer += A

print(answer)
from sys import stdin


def main():
    A, B, K = [int(x) for x in stdin.readline().rstrip().split()]
    tmp = list(range(A, B + 1))
    a = tmp[:K]
    b = tmp[-K:]
    c = sorted(list(set(a + b)))
    for x in c:
        print(x)


if __name__ == '__main__':
    main()


### FIXED CODE ###

from sys import stdin


def main():
    A, B, K = [int(x) for x in stdin.readline().rstrip().split()]
    a = [x for x, y in zip(range(A, B + 1), range(K))]
    b = [x for x, y in zip(range(B, A - 1, -1), range(K))]
    c = sorted(list(set(a + b)))
    for x in c:
        print(x)


if __name__ == '__main__':
    main()
N = int(input())
A = list(map(int,input().split()))
A.sort()
import fractions
X1 = A[0]
Y = 1
for i in range(1, N):
    X2 = X1 // fractions.gcd(X1, A[i]) * A[i]
    Y *= int(X2/X1)
    Y += int(X2/A[i])
    Y = Y%(10**9+7)
    X1 = X2
print(Y)

### FIXED CODE ###

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

import fractions

X = A[0]
for i in range(1, N):
    X = X*A[i] // fractions.gcd(X, A[i])

output = 0
D =10**9+7
X = X%D

for i in range(N):
    output += X*pow(A[i],D-2,D)%D
    output = output % (10**9+7)
print(int(output))
import sys
from math import ceil, log2

input = sys.stdin.readline

def main():
    MOD = 10**9 + 7
    
    N = int(input())
    A = list(map(int, input().split()))
    K = ceil(log2(max(A)))
    
    nums = [[0,0] for i in range(K)]
    ks = [(i, 2**i) for i in range(K)]
    
    A_ = [[] for i in range(N)]
    
    for i, a in enumerate(A):
        for j, k in ks:
            n = a & k > 0
            A_[i].append(n)
            nums[j][n] += 1
            
    ans = 0
    
    for a in A_:
        for i, n in enumerate(a):
            nums[i][n] -= 1
            ans += ks[i][1] * nums[i][not n] % MOD
            
    print(ans%MOD)

if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
input = sys.stdin.readline
import numpy as np

def main():
    N = int(input())
    A = np.array(list(map(int, input().split())))
    ans = 0
    MOD = 10**9+7
    k = 1
    x = np.max(A)
    n = 1 if x == 0 else int(np.log2(x))+1

    for i in range(n):
        c = np.count_nonzero(A%2)
        A >>= 1
        ans = (ans + c * (N-c) * k) % MOD
        k = (2*k) % MOD

    print(ans)

if __name__ == '__main__':
    main()
n,m=map(int,input())
n,m=min(n,m),max(n,m)
if n==1:
    print(max(0,m-2))
    exit()
else:
    print(max(0,(n-2)*(m-2)))

### FIXED CODE ###

n,m=map(int,input().split())
n,m=min(n,m),max(n,m)
if n==1:
    if m==1:
        print(1)
    else:
        print(max(0,m-2))
        exit()
else:
    print(max(0,(n-2)*(m-2)))
s = input().split()
S = s[0]
T = s[1]

score = []
for i in range(len(S)-len(T)):
    U = s[i: i+len(T)]
    cnt = 0
    for j in range(T):
        if U[j] != T[j]:
            cnt = cnt + 1
        score.append(cnt)
print(min(score))



### FIXED CODE ###

S = input()
T = input()

score = []
for i in range(len(S)-len(T)+1):
    U = S[i: i+len(T)]
    cnt = 0
    for j in range(len(T)):
        if U[j] != T[j]:
            cnt = cnt + 1
    score.append(cnt)
print(min(score))
h,w,k = map(int,input().split())
board = [list(input()) for _ in range]
ans = 0
for paint_h in range(2**h):
    for paint_w in range(2**w):
        cnt = 0
        for i in range(h):
            for j in range(w):
                if(paint_h>>i)&1==0 and (paint_w>>j)&1==0:
                    if board[i][j]=='#':
                        cnt += 1
        if cnt == k:    
            ans += 1
print(ans)

### FIXED CODE ###

h,w,k=map(int,input().split())
board=[list(input()) for _ in range(h)]
ans=0
for paint_h in range(2**h): #すべての行の塗りつぶし方を2進数で列挙する
 for paint_w in range(2**w): #すべての列の塗りつぶし方を2進数で列挙する
   cnt=0
   for i in range(h): #すべてのi行目j列目の要素についてみる
     for j in range(w):
       if (paint_h>>i)&1==0 and (paint_w>>j)&1==0: #各行のi番目のビットと各列のj番目のビットがともに0であればそのマスは塗りつぶされない
         if board[i][j]=='#': #塗りつぶされないマスが黒マスであれば個数を+1する
           cnt+=1
   if cnt==k: #塗りつぶされない黒マスの個数がKに等しければ答えを+1する
     ans+=1
print(ans)
import itertools
N, M = map(int, input().split())
A = [list(map(int, input().split())) for i in range(N)]
cnt=0
for l in range(1,N+1):
    for i in itertools.combinations(A,l):
        a=[0]*N
        for j,k in i:
            a[j-1]+=1
            a[k-1]+=1
        if a[0]==1 and a.count(1)==2 and a.count(2)==N-2:
            cnt+=1
print(cnt)
      

### FIXED CODE ###

import itertools
N, M = map(int, input().split())
p=[[0]*N for i in range(N)]
for i in range(M):
    a,b=map(int,input().split())
    p[a-1][b-1]=1
    p[b-1][a-1]=1
cnt=0
a=[i for i in range(N)]

for i in itertools.permutations(a):
    flag=0
    if i[0]==0:
        for j in range(1,N):
            if p[i[j]][i[j-1]]!=1:
                flag=1
        if flag==0:
            cnt+=1
    
print(cnt)
import sys
sys.setrecursionlimit(10000)
n = int(input())
count = 0
def f(n) :
    if n < 2 :
        return 1
    else:
        return n * f(n-2)

a = f(n)
while a % 10 == 0:
    count+= 1
    a //= 10

print(count)


### FIXED CODE ###

n = int(input())
x = 10
count = 0
if n % 2 == 0:
    while x <= n :
        count += n // x
        x *= 5
    print(count)
else:
    print(0)
import operator

def snuke_fest(top_arr, middle_arr, bottom_arr):
    sorted_arrs = list(sorted(arr) for arr in (top_arr, middle_arr, bottom_arr))
    del top_arr
    del middle_arr
    del bottom_arr
    pointers = [0] * 3
    ended = [False] * 3
    min_posi = [None] * len(sorted_arrs[0]) * 3
    min_posi_pointer = 0
    while not all(ended):
        nums = [0] * 3
        mins = [10**9] * 3
        for i in range(3):
            if not ended[i]:
                mins[-(i+1)] = sorted_arrs[i][pointers[i]]
        min_index, min_val = min(enumerate(mins), key = operator.itemgetter(1))
        min_index = 2 - min_index
        pointers[min_index] += 1
        min_posi[min_posi_pointer] = min_index
        min_posi_pointer += 1
        if pointers[min_index] == len(sorted_arrs[0]):
            ended[min_index] = True
    del sorted_arrs
    del pointers
    count = 0
    count_arr = [0, 0, 0]
    count_one_two = 0
    for i in range(len(min_posi)):
        count_arr[min_posi[-(i+1)]] += 1
        try:
            if min_posi[-(i+1)] == 1:
                count_one_two += count_arr[2]
            elif min_posi[-(i+1)] == 0:
                count += count_one_two
        except Exception as e:
            return 0
    return count


if __name__ == "__main__":
    # run_test(find_even, test_pair)
    _ = input()
    top_arr = [int(i) for i in input().split(" ")]
    middle_arr = [int(i) for i in input().split(" ")]
    bottom_arr = [int(i) for i in input().split(" ")]
    print(snuke_fest(top_arr, middle_arr, bottom_arr))
# ===

### FIXED CODE ###

text1 = input()
text2 = input()

if text1 == text2[::-1]:
    print("YES")
else:
    print("NO")