Harryxun/stf_run huggingface dataset:
num = [int(i) for i in input().split()]
K = num[0]
X = num[1]

print([i for i in range(X-K+1, X+K)]

### FIXED CODE ###

num = [int(i) for i in input().split()]
K = num[0]
X = num[1]
 
ans = [i for i in range(X-K+1, X+K)]
for i in range(2*K-1):
  print(ans[i], end=' ')
n,k = map(int,input().split())
a = list(map(int,input().split()))

ans = 1145141919810364364334
for i in range(1,2**n):
    ls = [0] * n
    qq = []
    
    for j in range(n):
        if (i >> j) & 1:
            ls[j] = 1
            qq.append(j)
            
    if sum(ls) < k:
        continue
        
    elif ls[0] == 1:
        t = []
        for j in qq:
            t.append(a[j])
        
        mt = t[0]
        cost = 0
        for j in range(len(qq) - 1) :
            if t[j+1] <= mt:
                cost += (mt + 1 - t[j+1])
                mt += 1
            else:
                mt = max(t[j+1] ,a[:qq[j+1]])
    else:
        continue
                
    ans = min(ans,cost)
    
print(ans)

### FIXED CODE ###

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

ans = 1145141919810364364334
for i in range(1,2**n):
    ls = [0] * n
    qq = []
    
    for j in range(n):
        if (i >> j) & 1:
            ls[j] = 1
            qq.append(j)
            
    if sum(ls) < k:
        continue
        
    else:
        mt = a[0]
        cost = 0
        for j in range(1,n) :
            if mt < a[j]:
                mt = a[j]
            else:
                if ls[j] == 1:
                    cost += mt + 1 - a[j]
                    mt += 1
    ans = min(ans,cost)
    
print(ans)
import fraction
from functools import reduce

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

def lcm_base(x, y):
    return (x * y) // fraction.gcd(x, y)

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

x = lcm_list(a)
ans = 0

for i in a:
    ans += (x//x)
    ans %= 1000000007

print(ans)

### FIXED CODE ###

import fractions
from functools import reduce

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

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

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

x = lcm_list(a)
ans = 0

for i in a:
    ans += (x//i)
ans %= 1000000007

print(ans)
N = int(input())
a = list(map(int, input().split()))
l = [0]*10**5+2

for i in a:
    l[i] +=1
    l[i+1] +=1
    l[i+2] +=1

print(max(l))

### FIXED CODE ###

N = int(input())
a = list(map(int, input().split()))
l = [0]*(10**5+2)

for i in a:
    l[i] +=1
    l[i+1] +=1
    l[i+2] +=1

print(max(l))
from math import factorial

n,k = map(int,input().split())
mod = 10**9+7

def comb(n,r):
    return factorial(n) / (factorial(r) * factorial(n-r))

for i in range(1,k+1):
    if i > n-k+1:
        print(0)
    else:
        x = comb(k-1,i-1) % mod
        y = comb(n-k+1,i)
        print(int(x*y) % mod)


### FIXED CODE ###

from math import factorial

n,k = map(int,input().split())
mod = 10**9+7

def cmb(n,r):
    return factorial(n) // (factorial(r) * factorial(n-r))

for i in range(1,k+1):
    if n-k+1 < i or k-1 < i-1:
        print(0)
    else:
        x = cmb(k-1,i-1) % mod
        y = cmb(n-k+1,i) % mod
        ans = (x*y) % mod
        print(int(ans))
nums = map(int,input().split())

nums.sort()


if nums[1] == nums[2] and nums[0]<nums[1]:
    print(True)
elif nums[1] == nums[0] and nums[1]<nums[2]:
    print(True)
else:
    print(False)


### FIXED CODE ###

nums= input().split()


for i in range(len(nums)):
    nums[i] = int(nums[i])
    
nums.sort()


if nums[1] == nums[2] and nums[0]<nums[1]:
    print("Yes")
elif nums[1] == nums[0] and nums[1]<nums[2]:
    print("Yes")
else:
    print("No")
import math

x=int(input())
y=int(input())
if x%y != 0:
    print(x)
else:
    print(-1)

### FIXED CODE ###

import math
import sys

x,y = map(int, input().split())
if x%y != 0:
    print(x)
else:
    print(-1)
n,k = map(int, input().split())
a = list(map(int, input(),split()))
ans = 0
for i in range(len(a)):
    if a[i] >= k:
        ans += 1
print(ans)

### FIXED CODE ###

n,k = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
for i in range(len(a)):
    if a[i] >= k:
        ans += 1
print(ans)
n = int(input())
a = list(map(int, input().split()))
c = [0]
d = c + a
s = [0 for _ in range(n + 1)]
 
for i in range(n, 0, -1):
    w = 0
    for j in range(2 * i, n + 1, i):
        w ^= s[j]
    s[i] = w ^ d[i]
    
print(b.count(1) if b.count(1) else 0)
for i in range(1, n + 1):
    if s[i] != 0:
        print(s[i], end=' ')

### FIXED CODE ###

N = int(input())
c = [0]
a = list(map(int, input().split()))
b = [0 for _ in range(N + 1)]

d = c + a

for i in range(N, 0, -1):
    s = 0
    for j in range(2 * i, N + 1, i):
        s ^= b[j]

    b[i] = (s ^ d[i])

# print(b)
print(b.count(1) if b.count(1) else 0)
if len(b):
    for i in range(1, len(b)):
        if b[i] != 0:
            print(i, end=' ')
else:
    print(0)
N,M,C=map(int,input().split())
B=input().split()
res=0
for i in range(N):
  sum=C
  A=input().split()
  for j in range(M):
    sum+=int(B[i])*int(A[i])
    if sum>0:
      res+=1
print(res)

### FIXED CODE ###

N,M,C=map(int,input().split())
B=input().split()
res=0
for i in range(N):
  sum=C
  A=input().split()
  for j in range(M):
    sum+=int(B[j])*int(A[j])
  if sum>0:
    res+=1
print(res)
import bisect

n = int(input())

a_list=[]
for i in range(n):
  a_list.append(int(input()))

ans_head=[99999]

for i in range(n-1,0,-1):
  a=a_list[i]
  if a>ans_head[-1]:
    ans_head.append(a)
  else:
    insert_index = bisect.bisect_right(ans_head,a)
    ans_head[insert_index]=a

  #print(ans_head)
print(len(ans_head))


### FIXED CODE ###

import bisect
n=int(input())
A=[]
for i in range(n):
  A.append(int(input()))
Ans=[A[-1]]
for i in reversed(range(n-1)):
  a=A[i]
  if a>=Ans[-1]:
    Ans.append(a)
  else:

    Ans[bisect.bisect_right(Ans,a)]=a

print(len(Ans))
h,n=map(int,input().split())
dp=[0]*(h+1010)
A=[list(map(int,input().split())) for i in range(n)]
dp[0]=0
for i in range(h+1010):
  dp[i]=min(dp[i-a]+b for a,b in A)
print(min(dp[h:]))


### FIXED CODE ###

def IN(): return map(int,input().split())
ans = pow(2,31); mod = pow(10,9)+7
h,n=IN()
A=[]; dp=[pow(2,31)]*111111
for i in range(n):
  x,y=IN()
  A.append((x,y))
dp[0]=0
for a,b in A:
  for i in range(h+1111):
    dp[i+a]=min(dp[i+a],dp[i]+b)
for i in range(h,11111):
  ans=min(ans,dp[i])
print(ans)
N, M = map(int, input().split())
num = [None] * (N)
ans = ''
for _ in range(M):
    x, y = map(int, input().split())
    if num[x-1] == None:
        num[x-1] = str(y)
    elif num[x-1] != str(y):
        ans = -1
        break

if ans == -1:
    print(ans)
elif len(num) >= 2 and num[0] == '0':
    print(-1)
elif len(num) >= 2 and num[0] == None:
    for i in range(N):
        if i == 0:
            ans += '1'
        else:
            if i == None:
                ans += '0'
            else:
                ans += i
    print(ans)
else:
    for i in num:
        if i == None:
            ans += '0'
        else:
            ans += i
    print(ans)

### FIXED CODE ###

N, M = map(int, input().split())
num = [None] * (N)
ans = ''
for _ in range(M):
    x, y = map(int, input().split())
    if num[x-1] == None:
        num[x-1] = str(y)
    elif num[x-1] != str(y):
        ans = -1
        break

if ans == -1:
    print(ans)
elif len(num) >= 2 and num[0] == '0':
    print(-1)
elif len(num) >= 2 and num[0] == None:
    for i in range(N):
        if i == 0:
            ans += '1'
        else:
            if num[i] == None:
                ans += '0'
            else:
                ans += num[i]
    print(ans)
else:
    for i in num:
        if i == None:
            ans += '0'
        else:
            ans += i
    print(ans)
from sys import stdin
import math


def main():
    A, B, C, D = [int(x) for x in stdin.readline().rstrip().split()]

    C_D = (C * D) // math.gcd(C, D)

    z = B//C_D - A//C_D

    if A % C == 0:
        x = (B//C) - (A//C) + 1
    else:
        x = (B//C) - (A//C)

    y = B//D - A//D

    print((B-A+1)-(x+y-z))


if __name__ == "__main__":
    main()


### FIXED CODE ###

from sys import stdin
import fractions


def main():
    A, B, C, D = [int(x) for x in stdin.readline().rstrip().split()]

    C_D = (C * D) // fractions.gcd(C, D)

    z = B//C_D - A//C_D

    if A % C == 0:
        x = (B//C) - (A//C) + 1
    else:
        x = (B//C) - (A//C)

    y = B//D - A//D

    print((B-A+1)-(x+y-z))


if __name__ == "__main__":
    main()
N = int(input())

in_list = []
for i in range(N):
    xyh = list(map(int, input().split()))
    in_list.append(xyh)

H = []
xy = []

for i, xyh in enumerate(in_list):
    x, y, h = xyh[0], xyh[1], xyh[2]

    if i == 0:
        for x1 in range(0, 101):
            for y1 in range(0, 101):
                H1 = h + abs(x-x1) + abs(y-y1)
                H.append(H1)
                xy.append([x1, y1])
    else:
        tmpH = []
        tmpxy = []
        for xy0, h0 in zip(xy, H):
            tm = h0-abs(x-xy0[0])-abs(y-xy0[1])
            if h == max(0, tm):
                tmpH.append(h0)
                tmpxy.append([xy0[0], xy0[1]])
        H = tmpH
        xy = tmpxy

print(xy[0][0], end=" ")
print(xy[0][1], end=" ")
print(H[0], end=" ")

### FIXED CODE ###

N = int(input())

in_list = []
x0, y0, h0 = 0, 0, 0
for i in range(N):
    xyh = list(map(int, input().split()))
    in_list.append(xyh)

for i in range(N):
    if in_list[i][2]:
        x0, y0, h0 = in_list[i]

for Cx in range(0, 101):
    for Cy in range(0, 101):
        for xyh in in_list:
            x, y, h = xyh[0], xyh[1], xyh[2]
            H = h0 + abs(x0-Cx) + abs(y0-Cy)
            if h != max(H-abs(x-Cx)-abs(y-Cy), 0):
                break
        else:
            print(Cx, Cy, H)
N, M = map(int, input().split(' '))

@lru_cache(maxsize=4096)
def fib(n):
    if n < 2:
        return n
    else:
        return fib(n - 1) + fib(n -2)

safe_area = []
a_p = int(input())
safe_area.append(a_p)
for i in range(M-1):
    a = int(input())
    diff = a - a_p
    if diff == 1:
        print('0')
        exit()
    safe_area.append(diff-1)
    a_p = a

safe_area.append(N - a_p)

sum = 1
for i in safe_area:
    sum *= fib(i)
print(sum % 1000000007)


### FIXED CODE ###

N, M = map(int, input().split(' '))

MOD = 1000000007

def fib(n):
    a, b = 0, 1
    for i in range(0, n):
        a, b = b, a + b
    return a

broken_step = []
p_a = -1
for i in range(M):
    a = int(input())
    if (a - p_a == 1):
        print("0")
        exit()
    else:
        p_a = a
    broken_step.append(a-1)

count_0 = 0
count_1 = 1
next_broken = 0
pre_is_broken = False
for i in range(N):
    if (next_broken >= len(broken_step) or i != broken_step[next_broken]):
        if (pre_is_broken):
            count_0 = 0
            pre_is_broken = False
        else:
            count_0, count_1 = count_1, count_0 + count_1
            count_0 %= MOD
            count_1 %= MOD
    else:
        next_broken+=1
        count_0 = 0
        pre_is_broken = True

print(count_1)
import bisect

n = int(input())
count = 0
a = [[0 for i in range(n)] for i in range(3)]

for i in range(3):
    a[i] = [int(x) for x in input().split()]
    a[i].sort()

# Binary Search
for i in a[1]:
    index0_left = bisect.bisect_left(a[0], i)
    while i == a[0][index0_left-1]:
        if index0_left == 0:
            break
        index0_left -= 1

    index2_right = bisect.bisect_right(a[2], i)
    while a[2][index2_right+1] == i:
        if index2_right > n:
            break
        index2_right += 1

    if ( i > a[0][index0_left-1] and a[2][index2_right+1] > i):
        count += (index0_left)*( n - index2_right)
        
print(count)

### FIXED CODE ###

import bisect

n = int(input())
count = 0
a = [[0 for i in range(n)] for i in range(3)]

for i in range(3):
    a[i] = [int(x) for x in input().split()]
    a[i].sort()

# Binary Search
for i in a[1]:
    index0_left = bisect.bisect_left(a[0], i)

    index2_right = bisect.bisect_right(a[2], i)

    count += (index0_left -1 + 1)*(n - index2_right)

print(count)
import heapq


def dijkstra_heap(s):
    d = [float("inf")] * n
    prev = [float("inf")] * n
    d[s] = 0
    edgelist = [[d[s], s]]
    heapq.heapify(edgelist)

    while edgelist:
        dis, v = heapq.heappop(edgelist)
        if d[v] < dis:
            continue

        for e in edge[v]:
            if d[e] > dis + 1:
                d[e] = dis + 1
                heapq.heappush(edgelist, [dis + 1, e])
                prev[e] = v
    return d, prev


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

edge = [[] for i in range(w)]
for i in range(w):
    x, y = map(int, input().split())
    x -= 1
    y -= 1
    edge[x].append(y)
    edge[y].append(x)
d, prev = dijkstra_heap(0)

if float('inf') in prev[1:]:
    print('No')
else:
    print('Yes')
    for i in prev[1:]:
        print(i + 1)


### FIXED CODE ###

import heapq


def dijkstra_heap(s):
    d = [float("inf")] * n
    prev = [float("inf")] * n
    d[s] = 0
    edgelist = [[d[s], s]]
    heapq.heapify(edgelist)

    while edgelist:
        dis, v = heapq.heappop(edgelist)
        if d[v] < dis:
            continue

        for e in edge[v]:
            if d[e] > dis + 1:
                d[e] = dis + 1
                heapq.heappush(edgelist, [dis + 1, e])
                prev[e] = v
    return d, prev


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

edge = [[] for i in range(n)]
for i in range(w):
    x, y = map(int, input().split())
    x -= 1
    y -= 1
    edge[x].append(y)
    edge[y].append(x)
d, prev = dijkstra_heap(0)

if float('inf') in prev[1:]:
    print('No')
else:
    print('Yes')
    for i in prev[1:]:
        print(i + 1)
n=int(input())
seqs =list(map(int,input().split()))
count = 0
for i in range(1,n+1):
    if i != seqs[i]:
        count += 1
if count <= 2:
    print("YES")
else:
    print("NO")

### FIXED CODE ###

n=int(input())
seqs =list(map(int,input().split()))
count = 0
for i in range(n):
    if i+1 != seqs[i]:
        count += 1
if count <= 2:
    print("YES")
else:
    print("NO")
a=int(input())
t=100
sum=0
while(t<a):
	t=math.floor(t*101/100)
	sum=sum+1
print(sum)


### FIXED CODE ###

import math
a=int(input())
t=100
sum=0
while(t<a):
	t=math.floor(t*101/100)
	sum=sum+1
print(sum)
N = int(input())

if N%4 == 0 or N%7 == 0 or N%11 == 0 or (N%4)%7 == 0 or (N%7)%4 == 0 or (N%11)%4 == 0 or (N%11)%7 == 0:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

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

if N%K == 0:
  print('0')
else:
  print('1')
N, K = map(int, input().split())


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

# 制約より
MAX_DICE = 1000*K

# 0-K番目を初期としてK個の値が最大になる範囲を探す
pos = 0
maxpos = pos
maxvalue = sum(dices[maxpos:maxpos+K])

for pos in range(1, N-K+1):
    if sum(dices[pos:pos+K]) > maxvalue):
        maxpos = pos
        maxvalue = sum(dices[pos:pos+K])

        # 上限
        if maxvalue == MAX_DICE:
            break

# 期待値を合計する
ans = 0
for dice in dices[maxpos:maxpos+K]:
    ans += (dice+1)/2


print(ans)

### FIXED CODE ###

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


# ruisekiwa
ruiseki = [0] * (n+1)

for i, x in enumerate(ary):
    ruiseki[i+1] = ruiseki[i] + x

kmax = 0
for i in range(n+1-k):
    ksum = ruiseki[i+k] - ruiseki[i]
    kmax = max(kmax, ksum)

print((kmax+k) / 2)
cnt = 0
def s(start, end):
    global cnt
    if(start==len(S)-1):
        return 
    numS = int(S[start:end+1])
    if(numS%2019==0 and numS!=0):
        cnt += 1
    if(end==len(S)-1):
        end = start+2
        s(start+1, end)
        return
    s(start, end+1)
S = input()
s(0, 1)
print(cnt)

### FIXED CODE ###

S = list(map(int, list(input())))[::-1]
N = len(S)
CNT = [0]*2019
CNT[0] = 1
num = 0
d = 0
for i in range(N):
    num += S[i]*pow(10, d, 2019)
    num %= 2019
    CNT[num] += 1
    d += 1
ans = 0 
for cnt in CNT:
    ans += (cnt*(cnt - 1)) // 2
print(ans)
l = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int (input())

print(l[k])

### FIXED CODE ###

l = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
k = int (input())
 
print(l[k-1])
MAX_N = 1_000_000_000
n, k = map(int, input().split())

for i in range(MAX_N):
    if n < pow(k, i):
        print(i)
        break


### FIXED CODE ###

MAX_N = pow(10, 9)
n, k = map(int, input().split())

for i in range(MAX_N):
    if n < pow(k, i):
        print(i)
        break
a, b,c = map(int, input().split())
  print(a,b,c)

### FIXED CODE ###

X,Y,Z=list(map(int, input().split()))
print(str(Z)+' '+str(X)+' '+str(Y))
from collections import Counter
    
n = int(input())
v = list(map(int, input().split()))

a = Counter(v[0::2]).most_common()
b = Counter(v[1::2]).most_common()
print(a)
print(b)
a.append([0,0])
b.append([0,0])
if a[0][0] != b[0][0]:
  print(n-(a[0][0]+b[0][0])
else:
  print(min(n-(a[0][0]+b[1][0]),n-(a[1][0]+b[0][0])))

### FIXED CODE ###

from collections import Counter
    
n = int(input())
v = list(map(int, input().split()))

a = Counter(v[0::2]).most_common()
b = Counter(v[1::2]).most_common()
a.append([0,0])
b.append([0,0])
if a[0][0] != b[0][0]:
  print(n-(a[0][1]+b[0][1]))
else:
  print(min(n-(a[0][1]+b[1][1]),n-(a[1][1]+b[0][1])))
inputs = list(map(lambda x: int(x), input().split()))
counter = ([1] * inputs[0]) + [0] * inputs[1] + [-1] * inputs[2]

if len(counter) < inputs[3]:
    inputs[3] = len(counter)
    
from functools import reduce

print(reduce(lambda x, y: x + y, counter[0:inputs[3]]))


### FIXED CODE ###

inputs = list(map(lambda x: int(x), input().split()))

max = 0
v = 1

for i in inputs[0:3]:
    if i > inputs[3]:
        i = inputs[3]
    max += v * i
    inputs[3] -= i
    v -= 1
    if inputs[3] <= 0:
        break

print(max)
a = map(int, input().split())
print(max(a) - min(a))

### FIXED CODE ###

*a, = map(int, input().split())
print(max(a) - min(a))
N , T  = map(int,input().split())
tmp_a = 1000
result = 1001
while N > 0:
 a,b = map(int,input().split())
 if b < T & a < tmp_a:
  result = N
  tmp_a = a
 N = N -1
if result == 1001:
 print('TLE')
else:
 print(result)

### FIXED CODE ###

N = int(input())
if N==1: 
 print('Hello World')
else:
 A = int(input())
 B = int(input())
 print(A + B)
def solve():
    n = int(input())

    def num_divisors_table(n):
        table = [0] * (n + 1)
        
        for i in range(1, n + 1):
            for j in range(i, n + 1, i):
                table[j] += 1
        
        return table

    table = num_divisors_table(n)
    print(sum(i*table[i] for i in range(n + 1))
solve()


### FIXED CODE ###

N = int(input())

a = 0
def g(x):
    y = N//x
    return y * (y+1)*x//2

print(sum(g(x) for x in range(1,N+1)))
a, b, h = map(int, input().split())
print(int((a+b)/2 * h))

### FIXED CODE ###

a = int(input())
b = int(input())
h = int(input())
print(int((a+b)*h/2))
class BIT():
	def __init__(self, n):
		self.n = n
		self.bit = [0]*(n+1)
	
	def getsum(self, k):
		ret = 0
		while k:
			ret += self.bit[k]
			k -= k&-k
		return ret
		
	def p_sum(self, i, j):
		return self.getsum(j)-self.getsum(i-1)
		
	def add(self, k, x):
		while k <= n:
			self.bit[k] += x
			k += k&-k

n,m,*t=map(int,open(0).read().split())
q=sorted([(a,b) for a,b in zip(*[iter(t)]*2)],key=lambda x:x[1]-x[0])
bit=BIT(n-1)
c=0
for a,b in q:
	if bit.p_sum(a,b-1)==0:
		bit.add(a,1)
		bit.add(b-1,1)
		c+=1
print(c)

### FIXED CODE ###

def solve():
	n,m,*t=map(int,open(0).read().split())
	r=sorted([(b,a)for a,b in zip(*[iter(t)]*2)])
	c=bef=0
	for b,a in r:
		if a>bef:
			c+=1
			bef=b-1
	print(c)
if __name__=="__main__":solve()
X= input()
X = int(X)
if X == 7 or X == 5 or X == 3:
  print "YES"
else:
  print "NO"

### FIXED CODE ###

N = input()
N = int(N)
if N == 7 or N == 5 or N == 3:
  print('YES')
else:
  print('NO')
import collections
import sys
N=int(input()) 
d=list(map(int, input().split())) 

c = collections.Counter(d)
if d[0] != 0:
  print(0)
  sys.exit()
c = dict(collections.Counter(d))
max_key = max(c.keys())

count = 1
for i in range(1,max_key):
  a = c.get(i, -1)
  b = c.get(i+1, -1)
  if a == -1:
    print(0)
    sys.exit()
  count = count * (a**b)

print(count)
  
  

### FIXED CODE ###

import collections
import sys
sys.setrecursionlimit(10**6+10)
N=int(input()) 
d=list(map(int, input().split())) 

  
  
c = collections.Counter(d)
c = dict(collections.Counter(d))

if d[0] != 0 or c[0]>1:
  print(0)
  sys.exit()
max_key = max(c.keys())


count = 1
for i in range(2,max_key+1):
  a = c.get(i, -1)
  b = c.get(i-1, -1)
  if a == -1 or b == -1:
    print(0)
    sys.exit()
  count = (count * (b**a))%998244353

print(count)
x,n = map(int,input().split())
if n == 0:
    print(x)
p = list(map(int,input().split()))

num1 = x

for i in range(n):
    num1 += 1
    if num1 not in p:
        dif1 = num1- x
        break

num2 = x
for k in range(n):
    num2 -= 1
    if num2 not in p:
        dif2 = x - num2
        break

if dif1 > dif2:
    print(num2)
elif dif1 < dif2:
    print(num1)
elif dif1 == dif2:
    print(num2)


### FIXED CODE ###

x,n = map(int,input().split())
if n == 0:
    print(x)
else:
    p = list(map(int,input().split()))
    
    if x not in p:
        print(x)
    else:

        num1 = x

        for i in range(n):
            num1 += 1
            if num1 not in p:
                dif1 = num1- x
                break

        num2 = x
        for k in range(n):
            num2 -= 1
            if num2 not in p:
                dif2 = x - num2
                break

        if dif1 > dif2:
            print(num2)
        elif dif1 < dif2:
            print(num1)
        elif dif1 == dif2:
            print(num2)
h, w, a, b = map(int, input().split())
for i in ragne(b):
    for j in range(a):
        print(1,end="")
    for j in range(w-a):
        print(0,end="")
    print()
for i in range(w-b):
    for j in range(a):
        print(0,end="")
    for j in range(w-a):
        print(1,end="")
    print()

### FIXED CODE ###

h, w, a, b = map(int, input().split())
for i in range(b):
    for j in range(a):
        print(0, end="")
    for j in range(w - a):
        print(1, end="")
    print()
for i in range(h - b):
    for j in range(a):
        print(1, end="")
    for j in range(w - a):
        print(0, end="")
    print()
n,k = map(int,input().split())
a = list(map(int,input().split()))
b = [0]*n

if(k > log2(n)):
    for i in range(n):
        print(n,end=" ")

else:
    for j in range(k):
        b = [0]*n
        for i in range(n):
            l = max(0,i-a[i])
            r = min(n-1,a[i]+i)
            b[l] += 1
            if(r+1<n):
                b[r+1] -= 1
        for i in range(1,n):
            b[i] += b[i-1]
        a = b


    for i in a:
        print(i,end=" ")


### FIXED CODE ###

from math import log2
n,k = map(int,input().split())
a = list(map(int,input().split()))
b = [0]*n

if(k > 10*log2(n) + 1):
    for i in range(n):
        print(n,end=" ")

else:
    for j in range(k):
        b = [0]*n
        for i in range(n):
            l = max(0,i-a[i])
            r = min(n-1,a[i]+i)
            b[l] += 1
            if(r+1<n):
                b[r+1] -= 1
        for i in range(1,n):
            b[i] += b[i-1]
        a = b


    for i in a:
        print(i,end=" ")
S=input()
count=0
result=[]
for i in S:
  if i=='A' or i=='T' or i=='G' or i=='C':
    count+=1
  else:
    result.append(count)
    count=0
print(max(result))

### FIXED CODE ###

S=input()
count=0
result=0
for i in S:
    if i in 'AGTC':
        count+=1
        result=max(result,count)
    else:
        count=0
print(result)