Harryxun/stf_run huggingface dataset:
n = int(input())
a = list(map(int,input().strip().split())
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)

### FIXED CODE ###

n = int(input())
a = list(map(int,input().strip().split()))
count = 0
for i in range(n):
    for j in range(n-1,i,-1):
        if a[j] < a[j-1]:
            a[j],a[j-1] = a[j-1],a[j]
            count += 1
print(' '.join(map(str,a)))
print(count)
a,b = ma-(int,input().split())
print(a + (b/2))

### FIXED CODE ###

a,b = map(int,input().split())
print(a + (b//2))
import sys
N, K = map(int, input().split())
s = input()
  
group = []
sign = s[0]
curr = 0
for i in range(N):
  curr += 1
  if s[i] != sign: 
    group += [curr-1]
    curr = 1
    sign = s[i]
else:group += [curr]

if s[0] == '0' :
  if s[N-1] == '0':
    m = (len(group)+1)//2
    if K >= m:
      print(N)
      sys.exit()
    score = [sum(group[:2*K])]
    for i in range(m-K):
      score += [score[-1] - group[2*i] + group[2*i+2*K]]
  else :
    0/0
    m = (len(group)+1)//2
    if K >= m:
      print(N)
      sys.exit()
    score = [sum(group[:2*K])]
    for i in range(m-K):
      score += [score[-1] - group[2*i] + group[2*i+2*K]]
    score[-1] += group[-1]
else:
  m = len(group)//2
  group += [0]
  if K >= m:
    print(N)
    sys.exit()
  score = [sum(group[:2*K+1])]
  for i in range(m-K):
    score += [score[-1] - group[2*i] - group[2*i+1] + group[2*i+2*K+1]+group[2*i+2*K +2]]

print(max(score))

### FIXED CODE ###

N, K = map(int, input().split())
s = input()
  
group = []
if s[0] == '0' :
  group = [0]
sign = s[0]
curr = 0
for i in range(N):
  curr += 1
  if s[i] != sign: 
    group += [curr-1]
    curr = 1
    sign = s[i]
else:group += [curr]
if s[-1] == '0':
  group += [0]

m = len(group)//2
if K >= m:
  print(N)
else:
  score = [sum(group[:2*K+1])]
  for i in range(m-K):
    score += [score[-1] - group[2*i]  - group[2*i+1] + group[2*i+2*K+1]+group[2*i+2*K+2]]
  
  print(max(score))
n = int(input())
tastes = list(map(lambda x:int(x), input().split()))

ans = 0

while len(tastes)>0:
    x = tastes.pop()
    for y in tastes:
        ans += x * y
        
print(ans)

### FIXED CODE ###

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

ans = max(0, a - (2*b))

print(ans)
def DFS(num):
    global time
    if D[num]==0:
        D[num]=time
        time +=1
    for i in M[num]:
        if color[i]=="white":
            color[num]="gray"
            color[i]="gray"
            DFS(i)
        elif color[i]=="gray":
            color[num]="black"
            color[i]="black"
            DFS(i)
        elif color[i]=="black":
            return


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

B=[]
point,cnt=0,0
while cnt<n*2:
    point=A[point]
    B.append(point)
    point -=1
    cnt +=1

M=[set() for _ in range(n+1)]
for i in range(len(B)-1):
    a,b=B[i],B[i+1]
    M[a].add(b)

time=1
color=["white" for _ in range(n+1)]
D=[0 for _ in range(n+1)]
DFS(A[0])
route=[]
for i in range(n+1):
    if color[i]=="black":
        route.append([D[i],i])

C=[]
for i in sorted(route):
    C.append(i[1])

k=k-D[C[0]]
print(C[k%len(C)])

### FIXED CODE ###

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

time=0
color=["white" for _ in range(n+1)]
D=[-1 for _ in range(n+1)]
C,s=[],A[0]
point=0
while 1:
    if color[s]=="white":
        color[s]="gray"
        C.append(s)
        D[s]=time
        time +=1
        s=A[s-1]
    else:
        point=D[s]
        break

loop=C[point:]
if k>len(C):
    k -=point+1
    print(loop[k%len(loop)])
else:print(C[k-1])
n, m = map(int, input().split())
abc = [list(map(int, input().split())) for x in range(m)]
 
nodemap = [[] for x in range(n + 1)]
 
for a, b, c in abc:
    nodemap[a].append([a, b, c])

changed = False

calced = [None for x in range(n + 1)]
calced[1] = 0

for i in range(n - 1):
    changed = False
    for nodes in nodemap:
        for node in nodes:
            now, nextnode, addvalue = node
            if calced[nextnode] == None or calced[nextnode] < calced[now] + addvalue:
                if calced[now] != None:
                    calced[nextnode] = calced[now] + addvalue
                changed = True
print("inf" if changed else calced[n])


### FIXED CODE ###

n, m = map(int, input().split())
abc = [list(map(int, input().split())) for x in range(m)]
nodes = [[] for x in range(n + 1)]

for a, b, c in abc:
    nodes[a].append([a, b, -c])

costs = [None for x in range(n + 1)]
costs[1] = 0
flg = True
for i in range(n):
    for a, b, c in abc:
        if costs[a] == None:
            continue
        if costs[b] == None or costs[b] < costs[a] + c:
            flg = False
            costs[b] = costs[a] + c
    # for node in nodes[1:]:
    #     for a, b, c in node:
    #         if costs[a] == None:
    #             continue
    #         if costs[b] == None or costs[b] > costs[a] + c:
    #             flg = False
    #             costs[b] = costs[a] + c
#     if flg:
#         print(costs[n])
#         break
#     flg = True
# else:
#     print("inf")

ans = costs[n]
negative = [False for x in range(n + 1)]
for i in range(n - 1):
    for a, b, c in abc:
        if costs[a] == None:
            continue
        if costs[b] == None or costs[b] < costs[a] + c:
            costs[b] = costs[a] + c
            negative[b] = True

        if negative[a] == True:
            negative[b] = True

print(negative[n] and "inf" or ans)
s = input()
t = input()

sdash = "".join(sorted(s))
tdash = "".join(sorted(t, reverse = True))

print("Yes" if sdash < tdash else "No")


### FIXED CODE ###

a, b = map(int, input().split())
print( int((a + b + 2 - 1) / 2) )
import math
N = int(input())
input_list = [int(input())for _ in range(N)]

def lcm(x, y):
    return (x * y) // math.gcd(x, y)
  
initial_num = 1
for i in input_list:
    t = lcm(initial_num, i)
    if  t > initial_num:
        initial_num = t
        
print(initial_num)

### FIXED CODE ###

N = int(input())
input_list = [int(input())for _ in range(N)]

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
  
def lcm(x, y):
    return (x * y) // gcd(x, y)
  
initial_num = 1
for i in input_list:
    t = lcm(initial_num, i)
    if  t > initial_num:
        initial_num = t
        
print(initial_num)
n,l=map(int,input().split())
s=sorted([input() for i in range(n)])
print(*s,sep="")

### FIXED CODE ###

a, b, c = map(int,input().split())
if a == 5 and b == 5:
  print("YES")
elif b == 5 and c == 5:
  print("YES")
elif a == 5 and c == 5:
  print("YES")
else:
  print("NO")
c=[input() for i in range(3)]
for j in range(3):
  print(c[i],end='')

### FIXED CODE ###

c=[input() for i in range(3)]
for i in range(3):
  print(c[i][i],end='')
N=int(input())
A=map(int, input().split())
for i in range(N):
  if A[i]%2==0:
    if A[i]%3==0 or A[i]%5==0:
      print('APPROVED')
      exit()

print('DENIED')    

### FIXED CODE ###

N=int(input())
A=list(map(int, input().split()))
for i in range(N):
  if A[i]%2==0:
    if A[i]%3!=0 and A[i]%5!=0:
      print('DENIED')
      exit()

print('APPROVED')
l=[int(input())for _ in range(4)]
print(min(l[0],l[1])+min(l[3],l[4]))


### FIXED CODE ###

a=int(input())
b=int(input())
c=int(input())
d=int(input())
print(min(a,b)+min(c,d))
s = str(input())
S = [int(s[i]) for i in range(len(s))]
K = int(input())
ans = 1
for i in S:
    if S[i] != 1:
        print(S[i])
        break



### FIXED CODE ###

s = str(input())
S = [int(s[i]) for i in range(len(s))]
K = int(input())
ans = 1
count = 0
for i in range(min(len(S),K)):
    if S[i] != 1 and count == 0:
        ans = S[i]
        count += 1
        break
print(ans)
s = input()
print(s(0) + ( len(s)-2) + s(-1))

### FIXED CODE ###

s = input()
print(s[0] + str( len(s)-2) + s[-1])
N,K = map(int,input().split())
A = list(map(int,input().split()))
town = [[] for _ in range(N)]
visited = [0]

for i in range(N):
  town[i] = [i,A[i] - 1]

def teleport(i,con):
  goal = town[i][1]
  if goal in visited or con == K:
    return goal
  else:
    visited.append(goal)
    return teleport(goal,con + 1)

l = teleport(visited[0],0)

if K <= len(visited):
  print(visited[K] + 1)
else:
  cs = visited.index(l)
  cycle = visited[cs:]
  K = (K - len(visited)) % len(cycle)
  print(cycle[K] + 1)

### FIXED CODE ###

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

A = list(map(int,input().split()))
town = [[] for _ in range(N)]
visited = [0]
flag = [-1] * N

for i in range(N):
  town[i] = [i,A[i] - 1]

f = 0

while flag[f] == -1:
  t = town[f][1]
  flag[f] = t
  f = town[t][0]
  visited.append(t)
  
l = visited[-1]
lv = len(visited)

if K <= lv:
  print(visited[K] + 1)
else:
  cs = visited.index(l)
  cycle = visited[cs:-1]
  lc = len(cycle)
  print(cycle[(K - lv + 1) % lc] + 1)
##i
from collections import defaultdict, deque
N, Q = map(int, input().split())

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

operations = defaultdict(int)
for i in range(Q):
    p,q =  map(int, input().split())
    operations[p] += q


ans = defaultdict(int)

def func(node,p_node):
    ans[node] += operations[node]
    if p_node != 0:
        connection[node].remove(p_node)
    for c_node in connection[node]:
        ans[c_node] += ans[node]
        func(c_node, node)

func(1, 0)

print(' '.join(list(map(str, ans.values()))))

### FIXED CODE ###

import sys
sys.setrecursionlimit(200000)
from collections import deque

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

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

operations = [0] * N
for i in range(Q):
    p,q =  map(int, input().split())
    operations[p-1] += q

ans = [0] * N

stack = deque([1])
while len(stack)>0:
    node = stack.pop()
    ans[node-1] += operations[node-1]
    for node_c in connection[node-1]:
        connection[node_c-1].remove(node)
        ans[node_c-1] += ans[node-1]
        stack.append(node_c)

print(' '.join(map(str, ans)))
singular = input()
if singular[-1] == "s":
    print(singular + "es)
else:
    print(singular + "s")

### FIXED CODE ###

singular = input()
if singular[-1] == "s":
    print(singular + "es")
else:
    print(singular + "s")
r = int(input())
print(2 * π * r)

### FIXED CODE ###

import math

r = int(input())
print(2 * math.pi * r)
S = input()
T = input()

print(T+S)

### FIXED CODE ###

S_T = input().split()
S = S_T[0]
T = S_T[1]

print(T+S)
from statistics import median
from collections import deque

n = int(input())
x = deque(map(int, input().split()))

for i in range(0, len(x)):
    x_copy = x.copy()
    del x_copy[i]
    print(median(x_copy))

### FIXED CODE ###

n = int(input())
x = list(map(int, input().split()))
xsort = sorted(x)
x1, x2 = xsort[n//2-1], xsort[n//2]

for i in range(n):
    if x[i] <= x1:
        print(x2)
    else:
        print(x1)
A，B，C = list(map(int, input().split()))
vincent = [A,B,C]
vincent1 = list(set(vincent))
if len(vincent1) == 2:
  print('Yes')
else:
  print('No')


### FIXED CODE ###

A, B, C = list(map(int, input().split()))
vincent = [A,B,C]
vincent1 = list(set(vincent))
if len(vincent1) == 2:
    print("Yes")
else:
    print("No")
n,k=map(int,input().split())
h=list(map(int,input().split()))
def changemin(a,b):
    if a>b:
        a=b
        return a
    return a
dp=[]
dp.append(0)
for i in range(1,n):
    dp.append(1000000)
for m in range(1,n):
    for j in range(1,k+1):
        dp[m]=changemin(dp[m],dp[m-j]+abs(h[m]-h[m-j]))
        if m+j==n-1:
            break
print(dp[n-1])

### FIXED CODE ###

# educational DP contest A
n,k=map(int,input().split())
h=list(map(int,input().split()))
def changemin(a,b):
    if a>b:
        a=b
        return a
    return a
dp=[]
dp.append(0)
for i in range(1,n):
    dp.append(100000000000)
for m in range(n):
    for j in range(1,min(k+1,n-m)):
        dp[m+j]=changemin(dp[m+j],dp[m]+abs(h[m]-h[m+j]))
print(dp[n-1])
N = int(input())
  print((10**N -9**N -9**N +8**N)% (10**9+7))


### FIXED CODE ###

N = int(input())
print((10**N - 9**N - 9**N + 8**N) % (10**9+7))
#135c
N = str(input())
list_A = list(map(int, input().split()))
list_B = list(map(int, input().split()))

#print("#################################################")

ans = 0
remaining_power = 0

if N>1:
    for i in range(N-1,-1,-1):
        #print(i,"… RP:",remaining_power,",A:",list_A[i+1],",B:",list_B[i])

        if remaining_power>list_A[i+1]:
            #余力のみで倒せる
            remaining_power=list_B[i]
            ans += list_A[i+1]
            #print("margin")
        elif remaining_power + list_B[i] > list_A[i+1]:
            #余力と勇者で倒せる
            remaining_power = list_B[i] - (list_A[i+1] - remaining_power)
            ans += list_A[i+1]
            #print("OK")
        else:
            #余力と勇者でも倒せない
            ans += remaining_power + list_B[i]
            remaining_power = 0
            #print("No")
else:
    remaining_power = list_B[0] 
            
if remaining_power > list_A[0]:
    ans += list_A[0]
else:
    ans += remaining_power
        
print(ans)

### FIXED CODE ###

#135c
N = int(input())
list_A = list(map(int, input().split()))
list_B = list(map(int, input().split()))
 
#print("#################################################")
 
ans = 0
remaining_power = 0
 
if N>1:
    for i in range(N-1,-1,-1):
        #print(i,"… RP:",remaining_power,",A:",list_A[i+1],",B:",list_B[i])
 
        if remaining_power>list_A[i+1]:
            #余力のみで倒せる
            remaining_power=list_B[i]
            ans += list_A[i+1]
            #print("margin")
        elif remaining_power + list_B[i] > list_A[i+1]:
            #余力と勇者で倒せる
            remaining_power = list_B[i] - (list_A[i+1] - remaining_power)
            ans += list_A[i+1]
            #print("OK")
        else:
            #余力と勇者でも倒せない
            ans += remaining_power + list_B[i]
            remaining_power = 0
            #print("No")
else:
    remaining_power = list_B[0] 
            
if remaining_power > list_A[0]:
    ans += list_A[0]
else:
    ans += remaining_power
        
print(ans)
N = int(input())
L = map(int, input().split())
sort(L)
sum = 0
for i in range(0,N):
    sum += L[i*2]
print(sum)

### FIXED CODE ###

N = int(input())
L = [int(x) for x in input().split()]
list.sort(L)
sum = 0
for i in range(0,len(L),2):
	sum += L[i]
print(sum)
# -*- Coding: utf-8 -*-

import numpy as np

H,W=int(input().split())
h,w=int(input().split())

mat=np.ones((H,W))
mat[0:h,:]=0
mat[:,0:w]=0

print(np.sum(mat))

### FIXED CODE ###

# -*- Coding: utf-8 -*-

import numpy as np

INPUT=input().split()
Input=input().split()
H,W=int(INPUT[0]),int(INPUT[1])
h,w=int(Input[0]),int(Input[1])

mat=np.ones((H,W))
mat[0:h,:]=0
mat[:,0:w]=0

print(int(np.sum(mat)))
# ===================================
# (c) MidAndFeed aka ASilentVoice
# ===================================
# import math 
# import collections
# import string
# ===================================
n = int(input())
q = [int(x) for x in input().split()]
ans = [None for _ in range(n)]
ans[0] = 0

# Top down
def dp(current):
	if current < 0: return 0
	else:
		if ans[current] != None: return ans[current]
		
		t1 = t2 = int(1e9)
		if current-1 >= 0: t1 = abs(q[current] - q[current-1]) + dp(current-1)
		if current-2 >= 0: t2 = abs(q[current] - q[current-2]) + dp(current-2)

		ans[current] = min(t1, t2)
		return ans[current]

dp(n-1)

# Bottom up
# for i in range(1, n):
# 	t1 = t2 = int(1e9)
# 	if i-1 >= 0: t1 = ans[i-1] + abs(q[i-1] - q[i])
# 	if i-2 >= 0: t2 = ans[i-2] + abs(q[i-2] - q[i])
# 	ans[i] = min(t1, t2)

print(ans[n-1])


### FIXED CODE ###

# ===================================
# (c) MidAndFeed aka ASilentVoice
# ===================================
# import math 
# import collections
# import string
# ===================================
n = int(input())
q = [int(x) for x in input().split()]
ans = [None for _ in range(n)]
ans[0] = 0

# # Top down
# def dp(current):
# 	if ans[current] != None: return ans[current]

# 	if current < 0: return 0
# 	else:
# 		t1 = t2 = int(1e9)
# 		if current-1 >= 0: t1 = abs(q[current] - q[current-1]) + dp(current-1)
# 		if current-2 >= 0: t2 = abs(q[current] - q[current-2]) + dp(current-2)

# 		ans[current] = min(t1, t2)
# 		return ans[current]

# dp(n-1)

for i in range(1, n):
	t1 = t2 = int(1e9)
	if i-1 >= 0: t1 = ans[i-1] + abs(q[i-1] - q[i])
	if i-2 >= 0: t2 = ans[i-2] + abs(q[i-2] - q[i])
	ans[i] = min(t1, t2)
# print(ans)
print(ans[n-1])
n,m = map(int,input().split())
dp = [0] * (n+1)

mod = 10**9 + 7
for i in range(m):
    dp[int(input())] = -1 # 壊れているので、-1としておこう?

dp[0] = 0 # 0段目にいるとしよう
# 1段目が行けなかったら...?
dp[1] = 1 if dp[1] != -1 else -1 # 1段目にいく方法は1通り?
dp[2] = 2 if dp[1] != -1 else (1 if dp[2] != -1 else -1) # 2段目に行く方法は2通り?
for i in range(3,n+1):
    if dp[i] != -1 and dp[i-1] != -1:
        dp[i] += dp[i-1]
        dp[i] %= mod
    if i > 1:
        if dp[i] != -1 and dp[i-2] != -1:
            dp[i] += dp[i-2]
            dp[i] %= mod
print(dp[n]%mod)


### FIXED CODE ###

MOD = 10**9 + 7

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

ban = [False] * (n + 1)

for i in range(m):
    a = int(input())
    ban[a] = True

dp = [0] * (n + 1)
dp[0] = 1

for i in range(n):
    dp[i] %= MOD
    if ban[i]:dp[i] = 0
    #print(i, dp[i])
    if i + 1 <= n:
        dp[i + 1] += dp[i]
    if i + 2 <= n:
        dp[i + 2] += dp[i]

print(dp[n] % MOD)
def main():
    # input
    n = int(input())
    s = input()

    ans = 0
    for i in range(0, 1000):
        num = str(i)
        num = '0'*(3-len(num))+num
        index = 0
        for i in s:
            if index == 3:
                ans += 1
                break
            elif num[index]==i:
                index += 1
        else:
            if index == 3:
                ans += 1

    print(ans)

    # calc


if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    # input
    m1, d1 = map(int, input().split())
    m2, d2 = map(int, input().split())

    if d2 == 1:
        print(1)
    else:
        print(0)

    # calc


if __name__ == '__main__':
    main()
import numpy as np

S = input()
N = len(S)
arr = np.zeros((N, N), dtype=np.int)
for n, s in enumerate(S):
    i = n
    j = n + (1 if s == 'R' else -1)
    arr[i, j] += 1
mat = np.matrix(arr)
print(*(np.ones(N, dtype=np.int) * mat ** 10 ** 100).tolist()[0])

### FIXED CODE ###

import numpy as np
from scipy.sparse import csr_matrix

S = input()
N = len(S)
row = tuple(range(N))
col = [n + (1 if s == 'R' else -1) for n, s in enumerate(S)]
data = [1] * N
mat = csr_matrix((data, (row, col)), shape=(N, N))
print(*np.ones(N, dtype=np.int) * (mat ** 10 ** 100))
N=int(input())
A=int(input())
B=int(input())

if N==1:
    print("Hello World")
else:
    print(A+B)

### FIXED CODE ###

N=int(input())

if N==1:
    print("Hello World")
else:
    A=int(input())
    B=int(input())
    print(A+B)
n = int(input())
b=[0]*100000
for i in range(n):
  j=int(input())-1
  if b[j]:
    b[j]=0
  else:
    b[j]=1
print(sum(b))

### FIXED CODE ###

from collections import Counter 
n=int(input())
a=Counter([int(input()) for _ in range(n)])
ans=0
for i in a.values():
  ans+=i%2
print(ans)
import numpy as np  

n = int(input())
h = [list(map(int, input().split())) for _ in range(n)]

dp = np.zeros([n+1, 3])

for i, val in enumerate(h):
    for j in range(3):
        for k in range(3):
            if j != k:
                dp[i+1, k] = max(dp[i+1, k], dp[i, j] + val[k])

print(int(np.max(dp[n, :], axis=1)))

### FIXED CODE ###

import sys
import itertools
from operator import itemgetter #sortedの対象を決めたい
from fractions import gcd #最大公約数
from math import ceil, floor, sqrt, isinf #小数点切り上げ、切り捨て、平方根
from copy import deepcopy #参照で影響されないコピー
from collections import Counter, deque #要素ごとの出現回数、双方向アクセス可能データ型
import heapq
import numpy as np
from functools import reduce
sys.setrecursionlimit(200000)

input = sys.stdin.readline
# template

def retmax(a, b):
    if a > b:
        return a
    else:
        return b

def main():
    n = int(input())
    a = [list(map(int, input().split())) for _ in range(n)]

    dp = np.zeros([3, n+1])

    for i, a_l in enumerate(a):
        for j in range(3):
            for k in range(3):
                if j != k:
                    dp[k, i+1] = retmax(dp[k, i+1], dp[j, i] + a_l[k])

    print(int(np.max(dp[:, n], axis=0)))


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

x = -1

xa = 0
xb = 0

a_arr = []
b_arr = []

for temp_a in range(10001):
    xa = temp_a * 0.08
    if xa // 1 == a:
        a_arr.append(temp_a)

for temp_b in range(10001):
    xb = temp_b * 0.1
    if xb // 1 == b:
        b_arr.append(temp_b)

for aa in a_arr:
    if aa in b_arr:
        print(aa)
        exit(0)

print('-1')


### FIXED CODE ###

s = input()

ss = set(s)

if len(ss) == 1:
    print('No')
else:
    print('Yes')
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from sys import stdin
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(a,b):
	g = gcd(a,b)
	return a*b//g

a,b = list(map(int, stdin.readline().rstrip().split()))
ans = solve(a,b)
print(ans)


### FIXED CODE ###

# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from sys import stdin
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(l):
	n = len(l)
	

N = int(stdin.readline())
s,t = list(map(str, stdin.readline().rstrip().split()))
ans = ''
for i in range(N):
	ans += s[i] + t[i]
print(ans)
import sys
h,w=map(int,input().split())
lst=[[0 for i in range(w)]for j in range(h)]
for i in range(h):
  s=input().split()
  for j in range(len(s)):
    if s[j]=='#':
      lst[i][j]=1
if h,w==1,1:
  print('Yes')
  sys.exit()
for j in range(1,h-1):
  for k in range(1,w-1):
    if lst[j][k]==1:
      if lst[j-1][k]!=1 and lst[j+1][k]!=1 and lst[j][k-1]!=1 and lst[j][k+1]!=1:
        print('No')
        sys.exit()
if lst[0][0]==1:
  if lst[0][1]!=1 and lst[1][0]!=1:
    print('No')
    sys.exit()
if lst[h-1][0]==1:
  if lst[h-2][0]!=1 and lst[h-1][1]!=1:
    print('No')
    sys.exit()
if lst[0][k-1]==1:
  if lst[0][k-2]!=1 and lst[1][k-1]!=1:
    print('No')
    sys.exit()
if lst[h-1][k-1]==1:
  if lst[h-1][k-2]!=1 and lst[h-2][k-1]!=1:
    print('No')
    sys.exit()

print('Yes')


### FIXED CODE ###

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

s = [input() for _ in range(h)]

ans = 'Yes'

for i in range(1, h-1):
    for j in range(1, w-1):
        if s[i][j] == '#' and s[i-1][j] == '.' and s[i+1][j] == '.' and s[i][j-1] == '.' and s[i][j+1] == '.':
            ans = 'No'

print(ans)
def  makabe((float)num, (float)ko):
  ky=(num+ko)/2
  return ky



n=int(input())
g=list(map(float,input().split()))
g.sort()
ty=(g[0]+g[1])/2
for h in range(2,n):
  ty= makabe(ty,g[h])
  
print(ty)

### FIXED CODE ###

def  makabe(nam, co):
  ky=(nam+co)/2.0
  return ky



n=int(input())
g=list(map(int,input().split()))
g.sort()
ty=(g[0]+g[1])/2.0
for h in range(2,n):
  ty= makabe(ty,g[h])
  
print(ty)
list_len = int(input())
input_list = map(int, input().split)
even_list_len = list_len
count = 0

while:
	even_list = filter(lambda num: num & 2 , input_list)
	if list_len != even_list_len:
      break
     count += 1
    
print(count)

### FIXED CODE ###

input_list_len = int(input())
input_list = map(int, input().split())
even_list = input_list
even_list_len = input_list_len
count = 0

while True:
    even_list = list(filter(lambda num: num % 2 == 0, even_list))
    even_list_len = len(even_list)
    if input_list_len != even_list_len:
        break
    even_list = map(lambda num: num / 2, even_list)
    count += 1

print(count)