Harryxun/stf_run huggingface dataset:
n = int(input())
s = input()

import collections
dp = collections.defaultdict(int)
for i in range(n-1, -1, -1):
    for j in range(i+1, n):
        if s[i] == s[j]:
            dp[i,j] = dp[i+1, j+1] + (j - i > dp[i+1, j+1])
print(max(dp.values()))

### FIXED CODE ###

n = int(input())
s = input()

def check(length):
    d = set()
    for i in range(n - 2 * length + 1):
        d.add(s[i:i + length])
        if s[i + length:i + 2 * length] in d:
            return True
    return False
 
 
lo = 0
hi = n // 2 + 1
while lo + 1 < hi:
    mid = (lo + hi) // 2
    if check(mid):
        lo = mid
    else:
        hi = mid
if check(hi):
	print(hi)
else:
  	print(lo)
def BubbleSort1(A,n):
    flag = 0
    count = 0
    while flag:
        for j in range(n-1, -1, -1):
            if A[j] < A[j-1]:
                A[j], A[j-1] = A[j-1], A[j]
                flag = 1
                count += 1

n = int(input())
A = [int(input()) for i in range(n)]

ans, count =  (BubbleSort(A,n))
ans = list(map(str,ans))

print (" ".join(ans))
print (count)

### FIXED CODE ###

n = int(input())
 
numbers = list(map(int, input().split(" ")))
 
cnt = 0
 
for i in range(n):
    for j in range(n - 1, i, -1):
        if numbers[j] < numbers[j - 1]:
            numbers[j],numbers[j - 1] = numbers[j - 1], numbers[j]
            cnt += 1
 
numbers = map(str, numbers)
print(" ".join(numbers))
 
print(cnt)
# D
x, y, z, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
a_l = []
a_max = a[0]
for i in range(len(a)):
    a_l.append(a[i] - a_max)
b_l = []
b_max = b[0]
for i in range(len(b)):
    b_l.append(b[i] - b_max)
c_l = []
c_max = c[0]
for i in range(len(c)):
    c_l.append(c[i] - c_max)
a_count = 0
b_count = 0
c_count = 0
while a_count * b_count * c_count < k:
    l = [a_l[a_count], b_l[b_count], c_l[c_count]]
    l.sort(reverse=True)
    for m in l:
        if m == a_l[a_count] and a_count < len(a):
            a_count += 1
        elif m == b_l[b_count] and b_count < len(b):
            b_count += 1
        elif m == b_l[b_count] and b_count < len(b):
            c_count += 1
    print(a_count, b_count, c_count)
a = a[:a_count+1]
b = b[:b_count+1]
c = c[:c_count+1]
print(a, b, c)
ans = []
for i in a:
    for j in b:
        for l in c:
            ans.append(i+j+l)
ans.sort(reverse=True)
for i in range(k):
    print(ans[i])

### FIXED CODE ###

# D
x, y, z, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)

ans = []
for index_i, i in enumerate(a):
    for index_j, j in enumerate(b):
        for index_l, l in enumerate(c):
            if ((index_i+1)*(index_j+1)*(index_l+1) <= k):
                ans.append(i+j+l)
            else:
                break
ans.sort(reverse=True)
for i in range(k):
    print(ans[i])
x,y = map(int,input.split())
if(x<1 or x>9 or y<1 or y>9):
  print("-1")
else:
  print(x*y)

### FIXED CODE ###

x,y = map(int,input().split())
if(x<1 or x>9 or y<1 or y>9):
  print("-1")
else:
  print(x*y)
n,a,b = map(int,input().split())

mod = 10**9+7
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

fac = [0]*(10**9+1)
fac[0] = 1
fac[1] = 1
for i in range(2,10**9+1):
    fac[i] = fac[i-1] * i % mod

c = pow(2,n,mod)
c -= 1
c -= ( fac[n] * modinv(fac[a]) )%mod * modinv(fac[n-a]) % mod
c -= (fac[n] * modinv(fac[b])) % mod * modinv(fac[n-b]) % mod
print(c%mod)

### FIXED CODE ###

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

mod = 10**9+7
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def com(n,k,mod=10**9+7):
    u = 1
    s = 1
    for i in range(n,n-k,-1):
        u = u*i % mod
    for i in range(k,0,-1):
        s = s*i % mod
    return u * modinv(s)

c = pow(2,n,mod)
c -= 1
c -= com(n,a)
c -= com(n,b)
print(c%mod)
N = int(input())
d = map(int, input().split())
more = N - 1
total = 0
for i in range(N):
  for j in range(more):
    try:
      total +=  int(d[i]) * int(d[i + j + 1])
    except IndexError:
      break
  more -= 1
print(total)

### FIXED CODE ###

N = int(input())
d = list(map(int, input().split()))
more = N - 1
total = 0
for i in range(N):
  for j in range(more):
    try:
      total +=  int(d[i]) * int(d[i + j + 1])
    except IndexError:
      break
  more -= 1
print(total)
import numpy as np
N = input()
list = list(map(int,input().split(' ')))

list = np.array(list)
A = list[list%2 == 0]
B = np.unique(np.append(list[list%6 == 0],(list[list%10 == 0])))
print(A)
print(B)

if (A == B).any() :
    print('APPROVED')
else:
    print('DENIED')


### FIXED CODE ###

import numpy as np
N = input()
list = list(map(int,input().split(' ')))

list = np.array(list)
A = np.unique(list[list%2 == 0])
B = np.unique(np.append(list[list%6 == 0],(list[list%10 == 0])))

if len(A) ==0:
        print('APPROVED')
elif len(B) ==0:
    print('DENIED')
else:
    if len(A) == len(B) :
        print('APPROVED')
    else:
        print('DENIED')
def debug(arg):
    if __debug__:
        pass
    else:
        import sys
        print(arg, file=sys.stderr)



k = (int(x) for x in input().split())

c = {} 
t = 0
for x in range(k, 0, -1):
    c[x] = (k // x) ** n
    c[x] = c[x] - sum(c[x * y] for y in range(2, k // x + 1))
    s = c[x] * x
    t += s
    # t = t % 1000000007

print(t)

### FIXED CODE ###

import itertools
import math

n = int(input())
c1 = range(1, n + 1)
c2 = itertools.combinations(range(1, n + 1), 2)
c3 = itertools.combinations(range(1, n + 1), 3)

t1 = sum(list(c1))
t2 = sum(list(map(lambda x: math.gcd(x[0], x[1]), c2))) * 6
t3 = sum(list(map(lambda x: math.gcd(x[0], math.gcd(x[1], x[2])), c3))) * 6

print(sum([t1, t2, t3]))
dx = [-1,-1,-1,0,0,1,1,1]
dy = [-1,0,1,-1,1,-1,0,1]
H,W,N = map(int,input().split())
s = []
d = {}
for i in range(N):
    x,y = map(int,input().split())
    if (x,y) not in s:
        d[(x,y)] = 0
        s.append((x,y))
    d[(x,y)] += 1
    for j in range(8):
        X = x + dx[j]
        Y = y + dx[j]
        if (X,Y) not in s:
            d[(x,y)] = 0
            s.append((X,Y))
        d[(X,Y)] += 1
ans = [H*W-len(s),0,0,0,0,0,0,0,0,0]
for (x,y) in s:
    ans[d[(x,y)]] += 1
for i in range(10):
    print(ans[i])

### FIXED CODE ###

dx = [-1,-1,-1,0,0,1,1,1,0]
dy = [-1,0,1,-1,1,-1,0,1,0]
H,W,N = map(int,input().split())
from collections import defaultdict, Counter
d = defaultdict(int)
for i in range(N):
    a,b = map(int,input().split())
    for j in range(9):
        A = a + dy[j]
        B = b + dx[j]
        f = 0
        if 2 <= A <= H-1:
            if 2 <= B <= W-1:
                f = 1
        if f == 1:
            d[(A,B)] += 1
s = 0
c = Counter(d.values())
for i in range(1,10):
    s += c[i]
c[0] = (H-2)*(W-2) - s
for i in range(10):
    print(c[i])
from math import modf
n, k, *A = map(int, open(0).read().split())
t = sum(A) / (n+k)
A = [a for a in A if int(a/t) >= 1]
c = k - sum(int(a/t)-1 for a in A)
X = []
for a in A:
    X.append(ceil(a / ceil(a/t)))
    X.append(ceil(a / int(a/t)))
X.sort()
print(X[-c-1])

### FIXED CODE ###

from math import ceil
n, k, *A = map(int, open(0).read().split())
t = sum(A) / (n+k)
A = [a for a in A if int(a/t) >= 1]
c = k - sum(int(a/t)-1 for a in A)
X = []
for a in A:
    X.append(ceil(a / ceil(a/t)))
    X.append(ceil(a / int(a/t)))
X.sort()
print(X[-c-1])
s = int(input())
res = Math.ceil(s/2)


### FIXED CODE ###

import math
s = input()
s = int(s)
s = s/2
s = math.ceil(s)
print(s)
import  heapq

n,m,s,t=map(int,raw_input().split())

nl=[ [ ] for j in range(n+1) ] 

for i in range(m):
	u,v,a,b=map(int,raw_input().split())
	nl[u].append( (v,a,b) )
	nl[v].append( (u,a,b) )


def dij(v,type):
	d=[ float("inf") for i  in range(n+1)]
	d[v]=0

	Q=[]
	heapq.heappush(Q,v)

	while Q:
		u=heapq.heappop(Q)
		for i in nl[u]:
			v=i[0]
			yen=i[1]
			sunuku=i[2]
			if type=="y":alt=d[u]+yen
			elif type=="s":alt=d[u]+sunuku

			if d[v]> alt:
				d[v]=alt
				heapq.heappush(Q,v)
	return d

d_y=dij(s,"y")
d_s=dij(t,"s")

val=float("inf")

A=[]
for i in range(n,0,-1):
	tmp=d_y[i]+d_s[i]
	val=min(val, tmp)
	A.append(val)

for i in reversed(A):
	print 10**15-i

### FIXED CODE ###

import heapq
 
N,M,S,T = map(int,input().split())
S,T = S-1,T-1
src = [tuple(map(int,input().split())) for i in range(M)]
 
es = [[] for i in range(N)]
for u,v,a,b in src:
    u,v = u-1,v-1
    es[u].append((v,a,b))
    es[v].append((u,a,b))
 
INF = float('inf')
cy = [INF] * N
cy[S] = 0
hq = [(0,S)]
heapq.heapify(hq)
while hq:
    cost,v = heapq.heappop(hq)
    for to,a,b in es[v]:
        if cost + a >= cy[to]: continue
        cy[to] = cost + a
        heapq.heappush(hq, (cy[to],to))
 
cs = [INF] * N
cs[T] = 0
hq = [(0,T)]
heapq.heapify(hq)
while hq:
    cost,v = heapq.heappop(hq)
    for to,a,b in es[v]:
        if cost + b >= cs[to]: continue
        cs[to] = cost + b
        heapq.heappush(hq, (cs[to],to))
 
ans = [INF]
for i in reversed(range(N)):
    tmp = cs[i] + cy[i]
    ans.append(min(ans[-1],tmp))
 
for a in reversed(ans[1:]):
    print(10**15 - a)
n=int(input())
h=map(int, input().split())
for i in range(n-1):
    if(h[i]<h[i+1]):
        h[i+1]-=1
    if(h[i]>h[i+1]):
        print('No')
        return
print('Yes')


### FIXED CODE ###

n=int(input())
h=list(map(int,input().split()))
for i in range(n-1):
    if(h[i]<h[i+1]):
        h[i+1]-=1
    if(h[i]>h[i+1]):
        print('No')
        exit()
print('Yes')
while True:
    n = raw_input()
    if not n:
        break
    else:
        n = int(n)
        print "3C{0:0>2}".format(n % 39)

### FIXED CODE ###

while True:
    try:
        n = int(raw_input())
        m = n % 39
        print "3C{0:0>2}".format(m if m != 0 else 39)
    except:
        break
n = int(input())
h = list(map(int, input().split()))
ans = 0
move = 0
for i in range(n):
  if h[i] >= h[i+1]:
    move += 1
    ans = max(ans, move)
  else:
    move = 0
print(ans)

### FIXED CODE ###

n = int(input())
h = list(map(int, input().split()))
ans = 0
move = 0
for i in range(n-1):
  if h[i] >= h[i+1]:
    move += 1
    ans = max(ans, move)
  else:
    move = 0
print(ans)
from math import lgamma
lfact = lambda n: lgamma(n + 1)
cmb = lambda n, r: lfact(n) - lfact(n - r) - lfact(r)

n,k = map(int,input().split())

#def cmb(n, k):
#    m = 1
#    if n < 2 * k:
#        k = n - k
#    for i in range(1, k + 1):
#        m = m * (n - i + 1) / i    
#    return m

for i in range(1,k+1):
    print(
            int(cmb(k-1, i-1) * cmb(n-k+1, i) % (10**9+7))
            )

### FIXED CODE ###

s = list(map(str, input()))

if s.count(s[0])==2:
    s_rm = [i for i in s if i != s[0]]
    if s_rm[0] == s_rm[1]:
        print("Yes")
    else:
        print("No")
else:
    print("No")
n = int(input())   
x = [input() for i in range(3)]
print(len(list(set(x))))



### FIXED CODE ###

n = int(input())   
x = [input() for i in range(n)]
print(len(list(set(x))))
n = int(input())
m = {}
for i in range(n):
    s = input()
    m[s] += 1

l = sorted(m.items, key=lambda x: x[1], reverse=True)
cnt = l[0][1]
p = []
for i in l:
    if i[1] == cnt:
        p.append(i[0])

p.sort()
for i in p:
  print(i)

### FIXED CODE ###

n = int(input())
m = {}
for i in range(n):
    s = input()
    if s in m:
        m[s] += 1
    else:
        m[s] = 1

l = sorted(m.items(), key=lambda x: x[1], reverse=True)
cnt = l[0][1]
p = []
for i in l:
    if i[1] == cnt:
        p.append(i[0])

p.sort()
for i in p:
  print(i)
n = int(input())
ans = [0] * n
for i in range(1,n):
  ans[i] = i
   
print(sum(ans))
  
  

### FIXED CODE ###

import math
n = int(input())
print(math.floor(((n-1)*(n-1+1))//2))
def tuika(newNode,pea):
    nodes[pea].append(newNode)
    if pea != 1:
        tuika(newNode, nodes[pea][0])

n, q = map(int, input().split())
nodes = [[] for _ in range(n+1)]
nodes[1].append(0)
counts = [0 for _ in range(n+1)]

for i in range(n-1):
    pea, chi = map(int, input().split())
    nodes[chi].append(pea)
    tuika(chi, pea)

for i in range(q):
    p, q = map(int, input().split())
    for j in range(1,len(nodes[p])):
        counts[nodes[p][j]] += q
    counts[p] += q

#print(counts[1:])
str_counts = map(str, counts[1:])
print(' '.join(str_counts))

### FIXED CODE ###

import sys
sys.setrecursionlimit(10 ** 6)
import sys
def input():
    return sys.stdin.readline()[:-1]
N , Q = map(int,input().split())
graph = [[] for _ in range(N)]
point = [0] * N
for _ in range(N - 1):
    a , b = map(int,input().split())
    graph[a - 1].append(b - 1)
    graph[b - 1].append(a - 1)
#print(graph)
for _ in range(Q):
    a , b = map(int,input().split())
    a = a - 1
    point[a] += b
# dfsを用いて累積和を計算する
# 初期状態だと前の値がないためデフォルト引数に-1を代入
def dfs(now , prev = -1):
    for next in graph[now]:
        # 次のノードが前に参照した値の時はcontinue
        if next == prev:
            continue
        # 現在の値を次のポイントに加算することで累積和をとる
        point[next] += point[now]
        # 次のノードと現在のノードを引数にdfsを継続する
        dfs(next , now)

dfs(0)
print(*point)
import math
a, b = map(int, input().split())
ans = a * b // math.gcd(a, b)
print(ans)


### FIXED CODE ###

import fractions
a, b = map(int, input().split())
ans = a * b // fractions.gcd(a, b)
print(ans)
from math import factorial

def comb(n, k):
    return factorial(n)//factorial(k)//factorial(n-k)

inp = input().split()

N = int(inp[0])
K = int(inp[1])

for i in range(1, K+1):
    print("%d"%(comb(N-K+1, i)*comb(K-1, i-1)%1000000007))

### FIXED CODE ###

from math import factorial

def comb(n, k):
    return factorial(n)//factorial(k)//factorial(n-k)

inp = input().split()

N = int(inp[0])
K = int(inp[1])

for i in range(1, K+1):
    if(i > N-K+1):
        print(0)
    else:
        print("%d"%(comb(N-K+1, i)*comb(K-1, i-1)%1000000007))
s = input()

result = re.fullmatch("(hi){1,5}",s)

if result == None:
    print("No")
else:
    print("Yes")

### FIXED CODE ###

import re

s = input()
 
result = re.fullmatch("(hi){1,5}",s)
 
if result == None:
    print("No")
else:
    print("Yes")
S=input()
if S[：4]=='YAKI'：
    print('Yes')
else：
    print('No')
 

### FIXED CODE ###

S = input()
if len(S) < 4:
    print("No")
    exit(0)
if S[:4] == "YAKI":
    print("Yes")
else:
    print("No")
N = input(int())
ans = 1

list = [i for i in input().split()]

for a in range(N-1):
  ans = ans * list[a]

  if ans > 10**18:
    ans = -1

print(ans)

### FIXED CODE ###

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

ans = 1

if 0 in a:
    print("0")
    exit()

for i in a:
    ans *= i

    if ans > 10**18:
        print("-1")
        exit()
        
print(ans)
MOD=10**10+7
n,m = list(map(int, input().split()))
a = set([int(input()) for _ in range(m)])

dp = [0] * (n+1)

if 1 in a and 2 in a:
    print(0)
    exit()
elif 1 in a:
    dp[2]=1
    dp[3]=2
    start=4
elif 2 in a:
    dp[1]=1
    dp[3]=2
    start=4
else:
    dp[1]=1
    dp[2]=2
    start=3
    
for step in range(start, n+1):
    if dp[step-1]==0 and dp[step-2]==0:
        break
    if step not in a:
        dp[step] = (dp[step-1] + dp[step-2])%MOD
print(dp[-1])

### FIXED CODE ###

MOD=10**9+7
n,m = list(map(int, input().split()))
a = set([int(input()) for _ in range(m)])

dp = [0] * (n+1)

dp[0] = 1
dp[1] = int(1 not in a)
for step in range(2, n+1):
    if dp[step-1]==0 and dp[step-2]==0:
        break
    if step not in a:
        dp[step] = (dp[step-1] + dp[step-2])%MOD
    else:
        dp[step] = 0
        
print(dp[-1])
from math import gcd
a,b = map(int, input().split())
print((a*b)//gcd(a,b))


### FIXED CODE ###

from fractions import gcd
a,b = map(int, input().split())
print((a*b)//gcd(a,b))
import math

a,b=map(int,input().split(" "))
def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(a, b))
#print(math.gcd(a, b))
# 2

### FIXED CODE ###

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

a,b=map(int,input().split(" "))
print(lcm(a, b))
n = int(input())
lists = [int(input()) for i in range(5)]
city = [0,0,0,0,0]
time = 0
phase = 1

while sum(city) < n*5:
    for i in range(phase):
        city[i] = min(n,city[i] + lists[i])
        for j in range(5):
            if city[j] > 0:
                phase = max(phase,j+2)
    time += 1

print(time)

### FIXED CODE ###

import math
n = int(input())
lists = [int(input()) for i in range(5)]

print(math.ceil(n/min(lists)) + 4)
while 1:
 H, W = map(int,raw_input().split())
 if H + W == 0:
???break
 for h in range(H):
  if h % 2 == 0:
   if W % 2 == 0:
    print ('#.'*(W//2))
   else:
    print ('#.'*(W//2)+'#')
   else:
    if: W % 2 == 0:
     print ('.#'*(W//2))
    else:
     print ('.#'*(W//2)+'.')
    print ''

### FIXED CODE ###

while 1:
 H, W = map(int,raw_input().split())
 if H + W == 0:break
 for h in range(H):
  if h % 2 == 0:
   if W % 2 == 0:
    print ('#.'*(W//2))
   else:
    print ('#.'*(W//2)+'#')
  else:
   if W % 2 == 0:
    print ('.#'*(W//2))
   else:
    print ('.#'*(W//2)+'.')
 print ''
a, b = input().split("\n")
array = map(int,b.split())
del array[0]
print(min(array), max(array), sum(array))


### FIXED CODE ###

input()
array = list(map(int, input().split()))
print(min(array), max(array), sum(array))
a = int(input)
print(a*800-(a//15)*200)

### FIXED CODE ###

a = int(input())
print(a*800-(a//15)*200)
import math

i = int(input())
print(i**2*math.pi, i*2*math.pi)

### FIXED CODE ###

import math

i = float(input())
print(i**2*math.pi, i*2*math.pi)
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n,m = inp()
print((n-1)*(m-1))

### FIXED CODE ###

from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n,m = inpl()
print((n-1)*(m-1))
a = list(map(str,input().split()))

num = 0

for i in range len a:
  if a[i] = "+":
    num +=1
  else:
    num -=1

print(num)

### FIXED CODE ###

s = input()

print(s.count("+")-s.count("-"))
import math

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

A, B = map(int, input().split())
print(lcm(A, B))



### FIXED CODE ###

from fractions import gcd

A, B = map(int, input().split())

print(A * B // gcd(A, B))
from decimal import Decimal
 
A,B = input().split()
 
A=int(A)
B=Decimal(B)
print(int(a*b))

### FIXED CODE ###

from decimal import Decimal
 
A,B = input().split()
 
A=int(A)
B=Decimal(B)
print(int(A*B))
A, B = map(int, input().split())

AB = list(range(A, B+1))

ans = []
while AB[-1] != 0:
    div = lambda x: x // 2
    rem = lambda x: x % 2
    
    AB_bit = list(map(rem, AB))
    AB = list(map(div, AB))
    ans.append(str(sum(AB_bit) % 2))
    
ans.reverse()
ans_10 = int(''.join(ans), 2)
print(ans_10)


### FIXED CODE ###

A, B = map(int, input().split())

def cal_xor(X):
    X = X+1
    xor_sum = 0
    digit = 1
    while digit < X:
        digit *= 2
        bit_count = (X // digit) * (digit // 2)
        bit_count += max(0, (X % digit) - (digit // 2))
        
        if bit_count % 2 == 1:
            xor_sum += digit // 2
    
    return xor_sum
        

ans = cal_xor(A-1) ^ cal_xor(B)
print(ans)
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))

a = int(input())
b = int(input())

if a+b >= 10:
    print("error")
else:
    print(a+b)



### FIXED CODE ###

#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))

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

if a+b >= 10:
    print("error")
else:
    print(a+b)
# Edit: 2014/11/15
# Lang: Python3
# Time: 00.xxs

# File: pc0021.py


if __name__ == "__main__":

    nset = int(input())

    for i in range(0, nset):

        x1, y1, x2, y2, x3, y3, x4, y4 = list(map(float, input().strip("\n").split(" ")))
        vABx = x2 - x1
        vABy = y2 - y1
        vCDx = x4 - x3
        vCDy = y4 - y3

        mx = vCDx / vABx
        my = vCDy / vABy

        if mx == my:
            print("YES")
        else:
            print("NO")

#

### FIXED CODE ###

# Edit: 2014/11/15
# Lang: Python3
# Time: 00.xxs

# File: pc0021.py


if __name__ == "__main__":

    nset = int(input())

    for i in range(0, nset):

        x1, y1, x2, y2, x3, y3, x4, y4 = list(map(float, input().strip("\n").split(" ")))
        vABx = x2 - x1
        vABy = y2 - y1
        vCDx = x4 - x3
        vCDy = y4 - y3

        #mx = vCDx / vABx
        #my = vCDy / vABy

        #if abs(mx - my) < 1e-10:
        if abs(vABx*vCDy - vCDx*vABy) < 1e-10:
            print("YES")
        else:
            print("NO")
        #print(mx-my)

#
import math

n = int(input())
for i in range(n):
    for i in range(2):
        x = int(input())
        y = int(input())
        result = x + y
        print(result) if math.log10(result) + 1 < 10 ** 80 else print("overflow")

### FIXED CODE ###

n = int(input())
for i in range(n):
    x = int(input())
    y = int(input())
    if x + y >= 10 ** 80:
        print("overflow")
    else:
        print(x + y)
n, a = map(int,input().split())
x = list(map(int,input().split()))

dp = [[[0] * n for i in range(n * a + 1)] for i in range(n)]
#print(*dp, sep='\n')
for i in range(n):
    for j in range(n * a + 1):
        for k in range(n):
            if i == 0:
                dp[0][x[0]][0] = 1
            else:
                if j == 0 and k == 0:
                    dp[i][x[i]][0] += 1
                    continue

                if dp[i - 1][j][k] == 0:continue
                dp[i][j][k] += dp[i - 1][j][k]
                if not(0 <= j + x[i] < n * a + 1):continue
                for l in range(n - 1):
                    dp[i][j + x[i]][l + 1] += dp[i - 1][j][l]
cnt = 0
for i in range(n * a + 1):
    if i != 0 and i % a == 0:
        temp = i // a
        cnt += dp[-1][i][temp - 1]
print(cnt)

### FIXED CODE ###

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

dp = [[[0] * n for i in range(n * a + 1)] for i in range(n)]
for i in range(n):
    for j in range(n * a + 1):
        for k in range(n):
            if i == 0 and x[0] < n * a + 1:
                dp[0][x[0]][0] = 1
                break
            else:
                if j == 0:
                    if k == 0 and x[i] < n * a + 1:
                        dp[i][x[i]][0] += 1
                    continue

                if dp[i - 1][j][k] == 0:continue
                dp[i][j][k] += dp[i - 1][j][k]
                if not(0 <= j + x[i] < n * a + 1):continue
                dp[i][j + x[i]][k + 1] += dp[i - 1][j][k]
cnt = 0
for i in range(n * a + 1):
    if i != 0 and i % a == 0:
        temp = i // a
        cnt += dp[-1][i][temp - 1]
print(cnt)
n = int(input())
lis = [chr(ord('a') + i) for i in range(26)]

m = n
i=1
while True:
    if m <= 26**i:
        break

    else:
        m -= 26**i
        i += 1

ans = []

for j in range(i-1, -1, -1):
    s1 = n // (26**j)
    if s1 == 0:
        ans.append(lis[s1])
    else:
        ans.append(lis[s1-1])
    n -= (26**j) * s1

print(''.join(ans))

### FIXED CODE ###

n = int(input())
lis = [chr(ord('a') + i) for i in range(26)]

i=1
while True:
    if n <= 26**i:
        break

    else:
        n -= 26**i
        i += 1

ans = []

for j in range(i-1, -1, -1):
    s1 = n // (26**j)
    s2 = n % (26**j)
    if s2 == 0:
        s1 -= 1
    if j > 0:
        if s1 >= 26:
            s1 = 25
            ans.append(lis[-1])
        else:
            ans.append(lis[s1])
        n -= (26**j) * s1
    elif j == 0:
        ans.append(lis[n-1])

print(''.join(ans))
A, B, K = [int(x) for x in input().split()]
X = list(range(A, B+1)))

o = set()
for i in X[:K]:
    print(i)
    o.add(i)

for i in X[-K:]:
    if i not in o:
        print(i)


### FIXED CODE ###

A, B, K = [int(x) for x in input().split()]

u = set(range(A, min(B+1, A+K)))
l = set(range(B, max(A-1, B-K),-1))
for i in sorted(u | l):
    print(i)