Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
n = int(input())

def f(x):
    a1 = int(str(x)[0])
    a2 = x%10
    return (a1, a2)

count = {}
for x in range(1, n+1):
    key = f(x)
    if key in count:
        count[key] += 1
    else:
        count[key] = 1

ans = 0
for x in range(1, n+1):
    a0, a1 = f(x)
    if a1 != 0:        # !
        key = (a1, a0) # swap
        ans += count[key]

print(ans)

Fixed submission:
from collections import defaultdict
n = int(input())

def f(x):
    a1 = int(str(x)[0])
    a2 = x%10
    return (a1, a2)

count = defaultdict(int)
for x in range(1, n+1):
    key = f(x)
    count[key] += 1

ans = 0
for x in range(1, n+1):
    a0, a1 = f(x)
    if a1 != 0:        # !
        key = (a1, a0) # swap
        ans += count[key]

print(ans)
Buggy python submission (verdict: Runtime Error):
def read():
    h, w, n = input().splitlines()
    return h, w, n


def calc(h, w, n):
    if h>w:
        return int(n / h) + 1
    else:
        return int(n / w) + 1

def main():
    print(calc(*read()))


if __name__ == "__main__":
    main()

Fixed submission:

def read():
    h = int(input())
    w = int(input())
    n = int(input())
    return h, w, n


def calc(h, w, n):
    if h > w:
        w = h
    
    if n % w  == 0:
        return int(n / w)
    else:
        return int(n/w)+1


def main():
    print(calc(*read()))


if __name__ == "__main__":
    main()
Buggy python submission (verdict: Runtime Error):
def myinput():
    n = input()
    s = input()
    return n, s

def rot(n, s):
    z = ord('Z')
    chars = []

    for c in s:
        code = ord(c) + n
        if code > z:
            code -= 26
        chars.append(chr(code))
    return ''.join(chars)

def main():
    n, s = myinput()
    ret = rot(n, s)
    print(ret)

main()


Fixed submission:
def myinput():
    n = int(input())
    s = input()
    return n, s

def rot(n, s):
    z = ord('Z')
    chars = []

    for c in s:
        code = ord(c) + n
        if code > z:
            code -= 26
        chars.append(chr(code))
    return ''.join(chars)

def main():
    n, s = myinput()
    ret = rot(n, s)
    print(ret)

main()
Buggy python submission (verdict: Runtime Error):
def count(k, s):
    answer = 0

    for a in range(s + 1):
        if a > k:
            break

        if s - a > 2*k:
            continue

        for b in range(a, s + 1):
            x = a - 0
            y = b - a
            z = s - b

            if y > k:
                break

            if z <= k and x + y + z == s:
                answer += 1

    return answer

if __name__ == '__main__':
    k, s = ' '.split(input())
    k = int(k)
    s = int(s)

    print(count(k, s))

Fixed submission:
def count(k, s):
    answer = 0

    for a in range(s + 1):
        if a > k:
            # aは増える一方なので
            break

        if s - a > 2*k:
            continue

        for b in range(a, s + 1):
            x = a - 0
            y = b - a
            z = s - b

            if y > k:
                break

            if z <= k and x + y + z == s:
                answer += 1

    return answer

k, s = map(int, input().split())
print(count(k, s))
Buggy python submission (verdict: Runtime Error):
#-*- coding: utf-8 -*-
import math

a, b = [int(x.strip()) for x in input().split()]
#print((a * b) // math.gcd(a, b))
print(6)









Fixed submission:
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(a, b):
    return 1 + 2 + 3 - a - b
    #if a + b + c <= 21: return 'win'
    #else: return 'bust'



do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    S = parsed_lines[1][0]
    return n, k, S


if not do_submit:
    a, b, c = input_parse("""
    3 1
    ABC
    """)
    print(sol(a, b, c))

    a, b, c = input_parse("""
    4 3
    CABA
    """)
    print(sol(a, b, c))

else:
    #a, b, c = list(map(int, input().split()))
    # S = input().split()
    a = int(input())
    b = int(input())
    # T = input()
    print(sol(a, b))
    # S = input().strip()
    # print(sol(S))
Buggy python submission (verdict: Runtime Error):
from collections import defaultdict
import sys
import math
from datetime import datetime
import re
import math
def sol(n, S, T):
    ans = ""
    for i in range(n):
        ans += S[i]
        ans += T[i]
    return ans





do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    # n = int(parsed_lines[0][0])
    # k = int(parsed_lines[0][1])
    S = parsed_lines[0][0]
    return S


if not do_submit:
    S = input_parse("""
    1905
    """)
    print(sol(S))

    S = input_parse("""
    0112
    """)
    print(sol(S))

    S = input_parse("""
    1700
    """)
    print(sol(S))

    S = input_parse("""
    0000
    """)
    print(sol(S))

    S = input_parse("""
    1001
    """)
    print(sol(S))



else:
    #A, B = list(map(int, input().split()))
    n = int(input())
    S = input()
    T = input()
    print(sol(n, S, T))

    # S = input().strip()
    # print(sol(S))

Fixed submission:
from collections import defaultdict
import sys
import math
from datetime import datetime
import re
import math
def sol(n, S, T):
    ans = ""
    for i in range(n):
        ans += S[i]
        ans += T[i]
    return ans





do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    # n = int(parsed_lines[0][0])
    # k = int(parsed_lines[0][1])
    S = parsed_lines[0][0]
    return S


if not do_submit:
    S = input_parse("""
    1905
    """)
    print(sol(S))

    S = input_parse("""
    0112
    """)
    print(sol(S))

    S = input_parse("""
    1700
    """)
    print(sol(S))

    S = input_parse("""
    0000
    """)
    print(sol(S))

    S = input_parse("""
    1001
    """)
    print(sol(S))



else:
    #A, B = list(map(int, input().split()))
    n = int(input())
    S, T = list(map(str, input().split()))
    # S = input()
    # T = input()
    print(sol(n, S, T))

    # S = input().strip()
    # print(sol(S))
Buggy python submission (verdict: Runtime Error):
#-*- coding: utf-8
#  -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(S, T):
    ans = 0
    for i in len(S):
        if S[i] == T[i]:
            ans += 1
    return ans


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    S = parsed_lines[1][0]
    return n, k, S


if not do_submit:
    a, b, c = input_parse("""
    3 1
    ABC
    """)
    print(sol(a, b, c))

    a, b, c = input_parse("""
    4 3
    CABA
    """)
    print(sol(a, b, c))

else:
    # n, k = list(map(int, input().split()))
    # S = input().split()
    S = input().split()
    T = input().split()
    print(sol(S, T))
    # S = input().strip()
    # print(sol(S))



Fixed submission:
#-*- coding: utf-8
#  -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(S, T):
    ans = 0
    for i in range(len(S)):
        #print("i:%s, S[i]:%s, T[i]:%s" % (i, S[i], T[i]))
        if S[i] == T[i]:
            ans += 1
    return ans


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    S = parsed_lines[1][0]
    return n, k, S


if not do_submit:
    a, b, c = input_parse("""
    3 1
    ABC
    """)
    print(sol(a, b, c))

    a, b, c = input_parse("""
    4 3
    CABA
    """)
    print(sol(a, b, c))

else:
    # n, k = list(map(int, input().split()))
    # S = input().split()
    S = input()
    T = input()
    print(sol(S, T))
    # S = input().strip()
    # print(sol(S))
Buggy python submission (verdict: Time Limit Exceeded):
#-*- coding: utf-8 -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime
import re


def sol(n, S):
    maxi = 0

    for i in range(n):
        tmp = 0
        for j in range(i, n):
            if j + 1 <= n -1:
                if S[j+1] <= S[j]:
                    tmp += 1
                else:
                    break
        maxi = max(maxi, tmp)
    return maxi

do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    #print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    #S = parsed_lines[0][0]
    return n, k


if not do_submit:
    n, k = input_parse("""
    5
10 4 8 7 3
    """)
    print(sol(n, k))

    n, k = input_parse("""
    100000 5
    """)
    print(sol(n, k))


else:
    n = int(input().strip())
    S = list(map(int, input().split()))
    #S = input()
    print(sol(n, S))

    # S = input().strip()
    # print(sol(S))





Fixed submission:
#-*- coding: utf-8 -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime
import re


def sol_lte(n, S):
    maxi = 0

    for i in range(n):
        tmp = 0
        for j in range(i, n):
            if j + 1 <= n -1:
                if S[j+1] <= S[j]:
                    tmp += 1
                else:
                    break
        maxi = max(maxi, tmp)
    return maxi


def sol(n, S):
    maxi = 0 # steps
    tmp = 0
    for i in range(1, n):
        if S[i] <= S[i-1]:
            tmp += 1
            maxi = max(maxi, tmp)
        else:
            tmp = 0

    return maxi


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    #print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    #S = parsed_lines[0][0]
    return n, k


if not do_submit:
    n, k = input_parse("""
    5
10 4 8 7 3
    """)
    print(sol(n, k))

    n, k = input_parse("""
    100000 5
    """)
    print(sol(n, k))


else:
    n = int(input().strip())
    S = list(map(int, input().split()))
    #S = input()
    print(sol(n, S))

    # S = input().strip()
    # print(sol(S))
Buggy python submission (verdict: Runtime Error):
#-*- coding: utf-8
#  -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(n, W):
    # oxoxoxoxoxoxox
    mini = sys.maxsize
    #print(n, W)
    for i in range(len(W)):
        #print(i)
        mini = min(abs(sum(W[0:i]) - sum(W[i:len(W)])), mini)
    #print("end")
    return mini


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    #print(parsed_lines)
    n = int(parsed_lines[0][0])
    W = [int(x) for x in parsed_lines[1]]
    # k = int(parsed_lines[0][1])
    # S = parsed_lines[1][0]
    # return n, k, S
    return n, W


if not do_submit:
    n, W = input_parse("""
    3
    1 2 3
    """)
    print(sol(n, W))

    n, W = input_parse("""
    4
    1 3 1 1
    """)
    print(sol(n, W))

else:
    n = int(input().split())
    W = list(map(int, input().split()))
    # print(sol(n, k, S))
    #S = input().strip()
    # S = input().strip()
    print(sol(n, W))



Fixed submission:
#-*- coding: utf-8
#  -*-
"""
oj dl https://atcoder.jp/contests/abc116/tasks/abc116_d -d test-d
oj test -d test-d -c "python abc116d.py"
oj test -d test-d -c "python abc116d.py" test-d/sample-3.in
"""
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(n, W):
    # oxoxoxoxoxoxox
    mini = sys.maxsize
    #print(n, W)
    for i in range(len(W)):
        #print(i)
        mini = min(abs(sum(W[0:i]) - sum(W[i:len(W)])), mini)
    #print("end")
    return mini


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    #print(parsed_lines)
    n = int(parsed_lines[0][0])
    W = [int(x) for x in parsed_lines[1]]
    # k = int(parsed_lines[0][1])
    # S = parsed_lines[1][0]
    # return n, k, S
    return n, W


if not do_submit:
    n, W = input_parse("""
    3
    1 2 3
    """)
    print(sol(n, W))

    n, W = input_parse("""
    4
    1 3 1 1
    """)
    print(sol(n, W))

else:
    n = int(input())
    W = list(map(int, input().split()))
    # print(sol(n, k, S))
    #S = input().strip()
    # S = input().strip()
    print(sol(n, W))
Buggy python submission (verdict: Runtime Error):
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(n, k, S):
    return S[:k-1]+S[k-1].lower()+S[k:]


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    S = parsed_lines[1][0]
    return n, k, S


if not do_submit:
    a, b, c = input_parse("""
    3 1
    ABC
    """)
    print(sol(a, b, c))

    a, b, c = input_parse("""
    4 3
    CABA
    """)
    print(sol(a, b, c))

else:
    n, k = list(map(int, input().split()))
    S = input().split()
    print(sol(n, k, S))
    # S = input().strip()
    # print(sol(S))


Fixed submission:
from collections import defaultdict
import sys
import math
from datetime import datetime

def sol(n, k, S):
    return S[:k-1]+S[k-1].lower()+S[k:]


do_submit = True
#do_submit = False

def input_parse(input_str):
    lines = [x.strip() for x in input_str.split("\n") if x.strip()]
    parsed_lines = [list(map(str, line.split())) for line in lines]
    print(parsed_lines)
    n = int(parsed_lines[0][0])
    k = int(parsed_lines[0][1])
    S = parsed_lines[1][0]
    return n, k, S


if not do_submit:
    a, b, c = input_parse("""
    3 1
    ABC
    """)
    print(sol(a, b, c))

    a, b, c = input_parse("""
    4 3
    CABA
    """)
    print(sol(a, b, c))

else:
    n, k = list(map(int, input().split()))
    S = input().split()
    print(sol(n, k, S[0]))

    # S = input().strip()
    # print(sol(S))
Buggy python submission (verdict: Runtime Error):
def sol(n, k):
    ans = int(n/2)+1 if n % 2 == 1 else int(n/2)
    return ans >= k

test = False
#test = True
if test:
    n, k = 3, 2
    #S =list( map(int, "1 6 3".split()))
    print(sol(n, k))

    n, k = 5, 5
    #S =list( map(int, "7 4 0 3".split()))
    print(sol(n, k))
    #
    n, k = 31, 10
    #S =list( map(int, "1000000000000".split()))
    print(sol(n, k))


else:
    n, k = map(int, input().split())
    S =list( map(int, input().split()))
    print(sol(k, S))

Fixed submission:
#-*- coding: utf-8 -*-
"""
https://yahoo-procon2019-qual.contest.atcoder.jp/tasks/yahoo_procon2019_qual_a
"""


def sol(n, k):
    ans = int(n/2)+1 if n % 2 == 1 else int(n/2)
    return 'YES' if ans >= k else 'NO'

test = False
#test = True
if test:
    n, k = 3, 2
    #S =list( map(int, "1 6 3".split()))
    print(sol(n, k))

    n, k = 5, 5
    #S =list( map(int, "7 4 0 3".split()))
    print(sol(n, k))
    #
    n, k = 31, 10
    #S =list( map(int, "1000000000000".split()))
    print(sol(n, k))

    n, k = 10, 90
    #S =list( map(int, "1000000000000".split()))
    print(sol(n, k))

else:
    n, k = map(int, input().split())
    #S =list( map(int, input().split()))
    print(sol(n, k))
Buggy python submission (verdict: Time Limit Exceeded):
def sol(k, S):
    maxi = 0
    for x in range(k+1):
        ttl = 0
        for s in S:
            ttl += (x ^ s)
        maxi = max(maxi, ttl)
    return maxi


test = False
if test:
    n, k = 3, 7
    S =list( map(int, "1 6 3".split()))
    print(sol(k, S))

    n, k = 4, 9
    S =list( map(int, "7 4 0 3".split()))
    print(sol(k, S))

    n, k = 1, 0
    S =list( map(int, "1000000000000".split()))
    print(sol(k, S))


else:
    n, k = map(int, input().split())
    S =list( map(int, input().split()))
    print(sol(k, S))


Fixed submission:
#-*- coding: utf-8 -*-
"""
https://atcoder.jp/contests/abc117/tasks/abc117_a
"""

def sol_naive(k, S):
    maxi = 0
    for x in range(k+1):
        ttl = 0
        for s in S:
            ttl += (x ^ s)
        maxi = max(maxi, ttl)
    return maxi


def keta(x):
    if x <= 0:
        return 0
    else:
        return 1 + keta(int(x/2))

def bin(x):
    return "{0:08b}".format(x)

def rec(k, S, b_keta, ans): # which digit
    #print("rec(%s, %s, %s, %s)" % (k, S, b_keta, ans))
    if b_keta == 0:
        #print("miso")
        return ans
    else:
        #print("soup")
        ones = 0
        for s in S:
            #print("checking %s and %s" % (bin(s), bin(1 << (b_keta-1))))
            if (1 << (b_keta-1) & s) > 0:
                #print("it's 1")
                ones += 1
        if ones < len(S) - ones: # should be set 1 in this digit
            if ans + (1 << (b_keta-1)) <= k:
                ans += (1 << (b_keta-1))
            #print("ans updated %s" % ans)
            return rec(k, S, b_keta-1, ans)
        else:
            return rec(k, S, b_keta-1, ans)


def sol(k, S):
    maxi = max(S)
    b_keta = keta(k)
    #print("find maxi(%s) and it's digit is %s and k is (%s)" % (maxi, b_keta, k))
    x = rec(k, S, b_keta, 0)
    ans = 0
    for s in S:
        ans += (x ^ s)
    return ans

test = False
#test = True
if test:
    n, k = 3, 7
    S =list( map(int, "1 6 3".split()))
    print(sol(k, S))

    n, k = 4, 9
    S =list( map(int, "7 4 0 3".split()))
    print(sol(k, S))
    #
    n, k = 1, 0
    S =list( map(int, "1000000000000".split()))
    print(sol(k, S))


else:
    n, k = map(int, input().split())
    S =list( map(int, input().split()))
    print(sol(k, S))
Buggy python submission (verdict: Runtime Error):
K,X = [int(x) for x in stdin.readline().rstrip().split()]
Ks = K * 500
if Ks < X:
  print('No')
else:
  print('Yes')

Fixed submission:
k,x = map(int,input().split())
ks = k * 500
if ks < x:
  print('No')
else:
  print('Yes')
Buggy python submission (verdict: Runtime Error):
a,b = input()

Fixed submission:
a,b = map(int,input().split())
if a*b%2 == 0:
  print("Even")
else:
  print("Odd")
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
s = []
for i in range(n):
    s.append(list(input()))
    s[i].sort()
    s[i] = ''.join(s[i])
    #print("{}".format(s[i]))

ans = 0
uniqs = set(s)
for orig in uniqs:
    occurence = s.count(orig)
    ans = ans + (occurence * (occurence -1)) // 2
print("{}".format(ans))

Fixed submission:
n = int(input())
counter = {}
uniqs = set()
for i in range(n):
    s = list(input())
    s.sort()
    s = ''.join(s)
    counter[s] = counter.get(s,0) + 1
    uniqs.add(s)
    #print("{}".format(s[i]))

ans = 0
for orig in uniqs:
    occurence = counter.get(orig)
    ans = ans + (occurence * (occurence -1)) // 2
print("{}".format(ans))
Buggy python submission (verdict: Time Limit Exceeded):
def trycand(first, second, nextcand):
    rest = nextcand.copy()
    rest.remove(second)
    n1 = first
    n2 = second
    while rest:
        try:
            n3 = n1 ^ n2
            rest.remove(n3)
            n1 = n2
            n2 = n3
        except ValueError:
            return False
    return True


n = input()

a = list(map(lambda x: int(x), input().split()))
first = a[0]
#print(first)
nextcand = a[1:]
#print(nextcand)

for second in nextcand:
    if trycand(first, second, nextcand):
        print("Yes")
        exit()

print("No")
exit()


Fixed submission:
n = input()

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

xor = 0

for i in a:
    xor = xor ^ i

if xor == 0:
    print("Yes")
else:
    print("No")
Buggy python submission (verdict: Runtime Error):
n = int(input())
a = list(map(int, input()))
s = round(sum(a)/n)
ans = 0
for i in a:
  ans += (i-s)**2
print(ans)

Fixed submission:
n = int(input())
a = list(map(int, input().split()))
s = round(sum(a)/n)
ans = 0
for i in a:
  ans += (i-s)**2
print(ans)
Buggy python submission (verdict: Runtime Error):
a = input().split()
p

Fixed submission:
a  = list(map(int,input().split()))

if a.count(5) == 2 and a.count(7) == 1:
  print("YES")
else:
  print("NO")
Buggy python submission (verdict: Runtime Error):
N = int(input())
S, T = input().split()
Answer = []
 
for i in range(N):
  Answer.append(S[i])
  Answer.append(T[i])
  
print(''.join(Answer))
 

Fixed submission:
A = int(input())
B = int(input())
 
Answer = [1, 2, 3]
 
Answer.remove(A)
Answer.remove(B)
 
print(Answer[0])

Buggy python submission (verdict: Runtime Error):
A = int(input())
B = int(input())

Answer = [1, 2, 3]

remove.Answer(A)
remove.Answer(B)

print(Answer[0])

Fixed submission:
A = int(input())
B = int(input())
 
Answer = [1, 2, 3]
 
Answer.remove(A)
Answer.remove(B)
 
print(Answer[0])
Buggy python submission (verdict: Runtime Error):
N = int(input())
S, T = input().split()
Answer = []

for i in N:
  Answer.append(S[i])
  Answer.append(T[i])
  
print(''.join(Answer))



Fixed submission:
N = int(input())
S, T = input().split()
X = []
 
for i in range(N):
  X.append(S[i])
  X.append(T[i])
  
print(''.join(X))
Buggy python submission (verdict: Runtime Error):
n = input()
number = len(n)
change = 0
for i in range(number//2):
  if n[i] != n[number - i]:
    change += 1
    
print(change)

Fixed submission:
n = input()
number = len(n)
change = 0
for i in range(number//2):
  if n[i] != n[number - i -1]:
    change += 1
    
print(change)
Buggy python submission (verdict: Runtime Error):
N = int(input())
S = input()
L=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
A = []
 
for c in S:
  i = L.find(c)
  A.append(L[(i + n)%26])
  
print(''.join(A))

Fixed submission:
N = int(input())
S = input()
L=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
A = []
 
for c in S:
  i = L.index(c)
  A.append(L[(i + N)%26])
  
print(''.join(A))

Buggy python submission (verdict: Runtime Error):
N = int(input())
S = input()
Alphabet=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
A = []

for c in S:
  i = Alphabet.find(c)
  A.append(Alphabet[(i + n)%26])
  
print(''.join(A))

Fixed submission:
N = int(input())
S = input()
L=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
A = []
 
for c in S:
  i = L.index(c)
  A.append(L[(i + N)%26])
  
print(''.join(A))