Harryxun/stf_run huggingface dataset:
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]

ans = 0

DP = [0] * T

for i in range(N):
  a, b = AB[i]
  for j in range(T - 1, -1, -1):
    if j + a >= T:
      ans = max(ans, DP[j] + b)
    else:
      DP[j + a] = max(DP[j + a], DP[j] + b)

for i in range(N):
  ans = max(ans, DP[i])
print(ans)

### FIXED CODE ###

N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]


AB.sort(reverse = True)
DP = [[0] * T for _ in range(N)]
DP[0][0] = AB[0][1]
for i in range(1, N):
  a, b = AB[i]
  DP[i][0] = max(DP[i - 1][0], b)
  for j in range(T):
    DP[i][j] = max(DP[i][j], DP[i - 1][j])
    if j + a < T:
      DP[i][j + a] = DP[i - 1][j] + b

print(max(DP[-1]))
x = int(input())
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])
    if arr==[]:
        arr.append([n, 1])
    return arr

c = factorization(x)
c.append([1,1])
c.append([x,1])

chk = False
for g in c:
  if chk:
    break
  s,t = g
  #print(s)
  for i in range(130):
    if (i+s)**5-i**5 > x:
      break
    if (i+s)**5-i**5 == x:
      ans = (i+s,i)
      chk = True
      break
  for p in range(1,130):
    j = -1*p
    #print(s,(j+s)**5-j**5)
    if (j+s)**5-j**5 > x:
      break 
    if (j+s)**5-j**5 == x:
      ans = (j+s,j)
      chk = True
      break 
      
print(*ans)

### FIXED CODE ###

x = int(input())
if x == 1:
  print(0,-1)
  exit()
  
def divisorize(fct):
    b, e = fct.pop()  # base, exponent
    pre_div = divisorize(fct) if fct else [[]]
    suf_div = [[(b, k)] for k in range(e + 1)]
    return [pre + suf for pre in pre_div for suf in suf_div]


def factorize(n):
    fct = []  # prime factor
    b, e = 2, 0  # base, exponent
    while b * b <= n:
        while n % b == 0:
            n = n // b
            e = e + 1
        if e > 0:
            fct.append((b, e))
        b, e = b + 1, 0
    if n > 1:
        fct.append((n, 1))
    return fct


def num(fct):
    a = 1
    for base, exponent in fct:
        a = a * base**exponent
    return a

c = []
fct = factorize(x)
for div in divisorize(fct):
    c.append(num(div))
    
chk = False
for s in c:
  if chk:
    break
  for i in range(1000):
    if (i+s)**5-i**5 > x:
      break
    if (i+s)**5-i**5 == x:
      ans = (i+s,i)
      chk = True
      break
  if s <1000:    
    for p in range(s,1000):
      j = -1*p
      #print(s,(j+s)**5-j**5)
      if (j+s)**5-j**5 > x:
        break 
      if (j+s)**5-j**5 == x:
        ans = (j+s,j)
        chk = True
        break 
  for ww in range(1,(s+1)//2)[::-1]:
    jj = -1*ww
    if (jj+s)**5-jj**5 > x:
      break    
    if (jj+s)**5-jj**5 == x:
      ans = (jj+s,jj)
      chk = True
      break 
print(*ans)
n = int(input())
a = int(input())
b = int(input())

print('Hello World' if n==1 else a+b)


### FIXED CODE ###

n = int(input())

print('Hello World' if n==1 else int(input())+int(input()))
from collections import Counter
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


INF = float('inf')

n = I()
a = LI()
ans = 1000
kabu = 0
vs = list(Counter(a).keys())
i = 0
m = len(vs)
# 極小値で売る、極大値で買う
while i < m:
    if 0 < i < m - 1:
        if vs[i-1] > vs[i] < vs[i+1]:
            # 買う
            ans, kabu = ans % vs[i], ans // vs[i]
            print(i, ans, kabu)

        elif vs[i-1] < vs[i] > vs[i+1]:
            # 売る
            ans, kabu = ans + vs[i] * kabu, 0
            # print(i, ans, kabu)
    else:
        if i == 0:
            if vs[i] < vs[i+1]:
                # 買う
                ans, kabu = ans % vs[i], ans // vs[i]
                # print(i, ans, kabu)
        else:
            if vs[i - 1] < vs[i]:
                # 売る
                ans, kabu = ans + vs[i] * kabu, 0
                # print(i, ans, kabu)
    i += 1
# print(i)

print(ans)


### FIXED CODE ###

import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


INF = float('inf')

n = I()
a = LI()
ans = 1000
for i in range(n - 1):
    kabu = 0
    if a[i] < a[i+1]:
        # 出来るだけ買う
        kabu = ans // a[i]
    # 買った株があれば i + 1日目 に売る
    if kabu > 0:
        ans += (a[i + 1] - a[i]) * kabu
print(ans)
a,b = input()
if a=="H" and b=="H" or a=="D" and b=="D":
    print("H")
else:
    print("D")


### FIXED CODE ###

a,b = input().split()
if a==b=="H" or a==b=="D":
    print("H")
else:
    print("D")
import copy
from collections import deque


def bfs(que, field):
    field[que[0]][que[1]] = 0
    moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]

    while que:
        c = que.popleft()
        for m in moves:
            my, mx = c[0] + m[0], c[1] + m[1]

            if field[my][mx] == ".":
                field[my][mx] = field[c[0]][c[1]] + 1
                que.append([my, mx])
            else:
                continue

    field = sum(field, [])
    return max([x for x in field if type(x) == int])


def main():
    H, W = map(int, input().split())
    field_s = []

    for h in range(H + 2):
        field_s.append(["#"] * (W + 2))
        if 1 <= h <= (H):
            field_s[h][1:-1] = list(map(str, input().rstrip()))

    start = []
    for y in range(1, H + 1):
        for x in range(1, W + 1):
            if field_s[y][x] == ".":
                start.append([y, x])

    ans = 0
    for s in start:
        que = deque([s])
        field = copy.deepcopy(field_s)
        ans = max(ans, bfs(que, field))

    print(ans)


if __name__ == '__main__':
    main()

### FIXED CODE ###

import copy
from collections import deque

H, W = map(int, input().split())
field_s = []

# フィールドを作る
for h in range(H + 2):
    field_s.append(["#"] * (W + 2))
    if 1 <= h <= (H):
        field_s[h][1:-1] = list(map(str, input().rstrip()))

#　動き方のセットを準備
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]

# スタート座標を取得
start = []
for y in range(1, H + 1):
    for x in range(1, W + 1):
        if field_s[y][x] == ".":
            start.append([y, x])

# 答え
ans = 0

for s in start:

    # fieldの初期化
    field = copy.deepcopy(field_s)

    # startをキューに追加
    que = deque([s])

    # startの距離は0に
    field[s[0]][s[1]] = 0

    # キューに何かがある限り探索を続ける
    while que:
        c = que.popleft()

        # 今の距離
        dist = field[c[0]][c[1]]

        # 動いた先が「.」なら、距離を記録してキューに追加
        for m in moves:
            my = c[0] + m[0]
            mx = c[1] + m[1]

            if field[my][mx] == ".":
                field[my][mx] = dist + 1
                que.append([my, mx])
            else:
                continue
    
    # キューを消化したら最大値を取り出す
    field = sum(field, [])
    ans = max(ans, max([x for x in field if type(x)==int]))

print(ans)
s = input()
ans = ""
for i in s:
  if(i == "9"):
    ans += "1"
  else if(i == "1"):
    ans += "9"
  else:
    ans += i
    
print(ans)

### FIXED CODE ###

s = input()
ans = ""
for i in s:
  if(i == '9'):
    ans += '1'
  elif(i == '1'):
    ans += '9'
  else:
    ans += i
    
print(ans)
import math

N = int(input())
inp_ints = list(map(int, input().split()))
# ints = list(set(inp_ints))

uniq_ints = list(set(inp_ints))
ints = uniq_ints
for m in uniq_ints:
    if inp_ints.count(m) >= 2:
        ints.append(m)

gcd = 0
result = 1
for i in range(len(ints)):
    gcd = 0
    for m in ints[:i]:
        gcd = math.gcd(gcd, m)
    for m in ints[i+1:]:
        gcd = math.gcd(gcd, m)
    if gcd > result:
        result = gcd

print(result)

### FIXED CODE ###

A, B, T = map(int, input().split())
result = T // A * B

print(result)
import numpy as np
import numpy.linalg as LA
a=[int(i) for i in input().split()]
a=[a,[int(i) for i in input().split()]]
a.append([int(i) for i in input().split()])
a = np.array(a)
if LA.det(a)==0:
  print('Yes')
else:
  print('No')


### FIXED CODE ###

d,e,f=[int(i) for i in input().split()]
x,y,z=[int(i) for i in input().split()]
s,t,u=[int(i) for i in input().split()]
b=x-d
c=s-d
if b+e==y and b+f==z and c+e==t and c+f==u:
    print('Yes')
else:
    print('No')
N, K = map(int, input().split())
P = list(map(int, input().split()))
ans = 0
for i in range(len(P) - K):
  ans = max(sum(P[i:i + K - 1], ans))
print((ans + K) / 2)

### FIXED CODE ###

from itertools import accumulate
N, K = map(int, input().split())
P = tuple(accumulate(map(int, input().split())))
ans = P[K - 1]
for i in range(N - K):
  ans = max(P[i + K] - P[i], ans)
print((ans + K) / 2)
import math

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

print(lcm(int(input())))

### FIXED CODE ###

import math
n = int(input())
print([n, 2*n][n % 2 > 0])
N, M = map(int, input().split())
lis = [0]*N
S = []
C = []
ERROR = False
for _ in range(N):
  s,c = map(int, input().split())
  S.append(s)
  C.append(c)
for i in range(len(S)-1):
  for j in range(i+1,len(S)):
    if S[i] == S[j] and C[i] != C[j]:
      ERROR = True
if ERROR:
  print('-1')
else:
  output = ''
  for i in range(len(S)):
    lis[S[i]-1] = C[i]
  for i in range(N):
    output += str(lis[i])
  if lis[0] == '0':
    print('-1')
  else:
    print(output)

### FIXED CODE ###

N, M = map(int, input().split())
lis = [0]*N
SC = []
ERROR = False
for _ in range(M):
  sc = list(map(int, input().split()))
  SC.append(sc)
for i in range(len(SC)-1):
  for j in range(i+1,len(SC)):
    if SC[i][0] == SC[j][0] and SC[i][1] != SC[j][1]:
      ERROR = True
for i in range(len(SC)):
  if N > 1 and SC[i][0] == 1 and SC[i][1] == 0:
    ERROR = True
if ERROR:
  print(-1)
else:
  output = ''
  for i in range(M):
    lis[SC[i][0]-1] = SC[i][1]
  if N > 1 and lis[0] == 0:
    lis[0] = 1
  for i in range(N):
    output += str(lis[i])
  print(int(output))
ary = list(map(lambda n: int(n), input().split(" "))).sort()
print(ary[0] + ary[1])

### FIXED CODE ###

ary = list(map(lambda n: int(n), input().split(" ")))
ary.sort()
print(ary[0] + ary[1])
n = int(input())
l = list(map(int, input().split()))

nl = sorted(l)

for i in range(n-1):
	other = 0 + n1[i]

if other < nl[n-1]:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

N = int(input())
L = sorted(list(map(int,input().split())))

if L[-1] < sum(L[0:N-1]):
    print("Yes")
else:
    print("No")
k, n = map(int, input().split())
a = list(map(int, input().split()))
a.sort()

zero = False
if 0 in a:
    a.remove(0)
    n = n - 1
    zero = True
    #print("contain 0.")

l1 = a[n-1] - a[0]  # 0を通らない側
l2 = a[0] + k - a[n-1]  # 0を通る側
if zero == True:
    ret = l2
else:
    ret = l1 if l1 < l2 else l2
print("{}".format(ret))

### FIXED CODE ###

s = input()
ret = "No"
if s[2] == s[3] and s[4]==s[5]:
    ret = "Yes"
print("{}".format(ret))
import copy
N, Q = map(int, input().split())
s = str(input())
TD = [list(map(str, input().split())) for i in range(Q)]

# どんどん合体していくことだけはわかった
hash = {}
for i in range(N):
    if s[i] in hash.keys():
        hash[s[i]].append(i)
    else:
        hash[s[i]] = [i]

for t, d in TD:
    if d == 'R':
        r_list = [i+1 for i in hash[t]]
        hash[t] = []
        for r in r_list:
            if 0 <= r <= N-1:
                hash[s[r]].append(r)
    else:
        l_list = [i-1 for i in hash[t]]
        hash[t] = []
        for l in l_list:
            if 0 <= l <= N - 1:
                hash[s[l]].append(l)

ans = 0
for d in hash.values():
    ans += len(d)
print(ans)

### FIXED CODE ###

N, Q = map(int, input().split())
S = str(input())
TD = [list(map(str, input().split())) for i in range(Q)]


def disappear(index, place):
    if index == -1:
        return (False, False)
    else:
        left = False
        right = False
        for t, d in TD:
            cur_chara = place[index]
            if t == cur_chara:
                if d == 'R':
                    index += 1
                else:
                    index -= 1
                if index < 0:
                    left = True
                    break
                elif index > N-1:
                    right = True
                    break
        return (left, right)


def binarySearch(place, direction):
    """
    :param direction; left, right
    :return: 消失する位置
    """
    start, end = -1, N
    if direction == 'left':
        while end - start > 1:
            t = start + (end - start) // 2
            if disappear(t, place)[0]:
                start = t
            else:
                end = t
        return start
    elif direction == 'right':
        while end - start > 1:
            t = start + (end - start) // 2
            if disappear(t, place)[1]:
                end = t
            else:
                start = t
        return start


left = binarySearch(S, direction='left')
right = binarySearch(S, direction='right')
print(right - left)
x =input().split(' ')
a = int(x[0])
b = int(x[1])
c = int(x[2])

if a <= b <= c:
    print(a, b, c)
elif a <= c <= b
    print(a, c, b)
elif b <=  a <= c:
    print(b, a, c)
elif c <= a <= b:
    print(c, a, b)
else:
    print(c, b, a)

### FIXED CODE ###

nums = input().split()
a = int(nums[0])
b = int(nums[1])
c = int(nums[2])
if a < b < c:
    print("Yes")
else:
    print("No")
sample = input()
new = []
for i in sample:
  new.append(i)
if "A" in new:
  a_pos = list.index(new)
if "Z" in new:
  z_pos = list.index(new)
out = new[a_pos:z_pos +1]
print(out)

### FIXED CODE ###

sample = input()
#new = list(sample)
#if "A" in new:
a_pos = sample.index('A')
#if "Z" in new:
z_pos = sample.rfind('Z')
print(z_pos-a_pos+1)
import numpy as np
a = np.array(input().split(),dtype=int)
sum  = a[0] + a[1] + a[2]
if sum > 21:
    print(bust)
else:
    print(win)


### FIXED CODE ###

import numpy as np
a = np.array(input().split(),dtype=int)
sum  = a[0] + a[1] + a[2]
if sum > 21:
    print("bust")
else:
    print("win")
while True:
    (H,W) = [int(x) for x in input().split()]
    if H == W == 0:
        break

    for hc in range(H):
        if hc == 0 or hc == H - 1:
                print('#'* W)
            else:
                print('#' + '.' * (W - 2) + '#')
    print()    

### FIXED CODE ###

while True:
    (H,W) = [int(x) for x in input().split()]
    if H == W == 0:
        break

    for hc in range(H):
        if hc == 0 or hc == H - 1:
            print('#'* W)
        else:
            print('#' + '.' * (W - 2) + '#')
    print()
import copy
n = int(input())
a = list(map(int,input().split()))
a2 = copy.copy(a)
c = 0
d = len(a)
for i in range(len(a)):
    if i+1 == len(a):
        ans = a[i-1] ^ a[0]
        if (ans in a2):
            try:
                a2.remove(ans)
            except e:
                break
        else:
            break
    else:
        ans = a[i-1] ^ a[i+1]
        if (ans in a2):
            try:
                a2.remove(ans)
            except e:
                break
        else:
            break
    c += 1
    print(a2)

if c == d:
    print("Yes")
else:
    print("No")



### FIXED CODE ###

n=int(input())
al=list(map(int,input().split()))
t=0
for a in al:
    t^=a
print('Yes' if t==0 else 'No')
l,r = map(int, input().split())
if (r - l >= 2019):
  print(0)
else:
  res = []
  for i in range(l, r + 1):
    res.append((i * j) % 2019)
  if(3 in res and 673 in res):
    print(0)
  else:
    print(res[0] * res[1])

### FIXED CODE ###

l,r = map(int, input().split())
if (r - l >= 2019):
  print(0)
else:
  res = []
  for i in range(l, r + 1):
    res.append(i % 2019)
  res.sort()
  ans = 2019 * 2019
  for hoge in res:
    for fuga in res:
      if(hoge != fuga and ans > ((hoge * fuga) % 2019)):
        ans = (hoge * fuga) % 2019
  print(ans)
n,a,d=map(int,input().split())

dic={}

ans=0
for k in range(n+1):
    l=k*a+k*(k-1)*d//2
    r=l+k*(n-k)*d
    idx=l%d
    l//=d
    r//=d
    if idx in dic:
        prel,prer=dic[idx]
        #共通部分ありか、なしかで分岐
        if prer<l or prel>r:
            dic[idx]=(l,r)
            ans+=r-l+1 
        else:
            nl=min(prel,l)
            nr=max(prer,r)
            ans+=prel-nl+nr-prer
            dic[idx]=(nl,nr)
    else:
        ans+=r-l+1 
        dic[idx]=(l,r)
print(ans)

### FIXED CODE ###

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

dic={}

ans=0

if d==0:
    if a==0:
        print(1)
    else:
        print(n+1)
else:
    for k in range(n+1):
        l=k*a+k*(k-1)*d//2
        r=l+k*(n-k)*d
        idx=l%d
        l//=d
        r//=d
        if idx in dic:
            prel,prer=dic[idx]
            #共通部分ありか、なしかで分岐
            if prer<l or prel>r:
                dic[idx]=(l,r)
                ans+=r-l+1 
            else:
                nl=min(prel,l)
                nr=max(prer,r)
                ans+=prel-nl+nr-prer
                dic[idx]=(nl,nr)
        else:
            ans+=r-l+1 
            dic[idx]=(l,r)
    print(ans)
N, M = map(int, input().split())
ans = [-1] * (N+1)
Flag = True

for i in range(M):
  s, c = map(int, input().split())
  if ans[s-1] < 0:
    ans[s-1] = c
  elif ans[s-1] == c:
    continue
  else:
    Flag = False

if N > 1:
  if ans[0] == 0:
    Flag = False
  elif ans[0] == -1:
    ans[0] = 1
    #三項演算子 真の値 if 条件式 else 偽の値
    ans = [0 if i == -1 else i for i in ans]

ans = ans[:N]

if Flag:
  print(int("".join([str(i) for i in ans])))
else:
  print(-1)

### FIXED CODE ###

N, M = map(int, input().split())
ans = ["0"] * (N)
Flag = True

for i in range(M):
  s, c = map(int, input().split())
  if ans[s-1] == "0":
    ans[s-1] = c
  elif ans[s-1] == c:
    continue
  else:
    Flag = False

if N > 1:
  if ans[0] == 0:
    Flag = False
  elif ans[0] == "0":
    ans[0] = 1

if Flag:
  print(int("".join([str(i) for i in ans])))
else:
  print(-1)
Target=input()
Target.swapcases()
print(Target)



### FIXED CODE ###

target=input()
Ans=target.swapcase()
print(Ans)
s = input()
length_s = len(s)
list_s = list()
for i in range(length_s):
    list_s.append(s[:1])
    s = s[1:]
length = length_s
while(length > 2):
    for j in range(length - 1):
        if(list_s[j] != list_s[j+1]):
            del list_s[j:j+2]
            break;
        length = len(list_s)
print(length_s - len(list_s))


### FIXED CODE ###

from collections import Counter
def counter(li, n):
    count = Counter()
    count.update(li)
    return count[n]

import sys
input = sys.stdin.readline
S = list(input())[:-1]
S = list(map(int, S))
N = len(S)
count_0 = counter(S, 0)
count_1 = N-count_0
print(N-abs(count_1-count_0))
from sys import stdin

def main():
    S=input()
    andbit = 2**10 -1
    ans = 0
    length = 2**(len(S) -1)
    
    for i in range (length):
      bitup = andbit & i
      bitcheck = 1
      tmp=0
      for j in range(1,len(S),1):
        if bitup & bitcheck > 0:
          ans += int(S[tmp:j])
          tmp = j
        bitcheck = bitcheck << 1
      ans += int(S[tmp:len(S)])
    print(ans)

input = lambda: stdin.readline()
main()


### FIXED CODE ###

from sys import stdin

S=input()
andbit = 2**10 -1
ans = 0
length = 2**(len(S) -1)
    
for i in range (length):
  bitup = andbit & i
  bitcheck = 1
  tmp=0
  for j in range(1,len(S),1):
    if bitup & bitcheck > 0:
      ans += int(S[tmp:j])
      tmp = j
    bitcheck = bitcheck << 1
  ans += int(S[tmp:len(S)])
print(ans)
s=input()
def check(s):
    if s=="":
        return True
    else:
        if len(s)>=7:
        	if s[-5:]=="dream" or s[-5:]=="erase":
                    return check(s[:-5])
                
            elif s[-7:]=="dreamer":
                    return check(s[:-7])
                
            elif s[-6:]=="eraser":
                    return check(s[:-6]) 
                
                
        elif len(s)==6:
            if s[-6:]=="eraser":
                return True
            
            else:
                return False
            
        elif len(s)==5:
            if s[-5:]=="dream" or s[-5:]=="erase":
                return True
            
            else:
                return False
            
        else:
            return False
        
if check(s):
    print("Yes")
else:
    print("No")


### FIXED CODE ###

s=input()
length=len(s)

s=s[::-1]

s=s+"WWWWWWW"

index=0
flag=True
while index<length:
    if s[index]=="m" and s[index+1]=="a" and s[index+2]=="e" and s[index+3]=="r" and s[index+4]=="d":
        index+=5
    elif s[index]=="e" and s[index+1]=="s" and s[index+2]=="a" and s[index+3]=="r" and s[index+4]=="e":
        index+=5   
    elif s[index]=="r" and s[index+1]=="e" and s[index+2]=="m" and s[index+3]=="a" and s[index+4]=="e" and s[index+5]=="r" and s[index+6]=="d":
        index+=7   
    elif s[index]=="r" and s[index+1]=="e" and s[index+2]=="s" and s[index+3]=="a" and s[index+4]=="r" and s[index+5]=="e":
        index+=6
    else:
        flag=False
        break
if flag:
    print("YES")
else:
    print("NO")
# -*- coding: utf-8 -*-

a, b, c = map(int, input().split())
int(b * ((t+0.5)//a))

### FIXED CODE ###

# -*- coding: utf-8 -*-
a, b, t = map(int, input().split())
print(int(b * ((t+0.5)//a)))
N, M = map(int, input().split())

counts = defaultdict(int)
numbers = {}

cities = []
for i in range(M):
    p, y = map(int, input().split())
    cities.append([i, p, y])

sorted_cities = sorted(cities, key=lambda x: x[2])
for city in sorted_cities:
    i, p, y = city
    counts[p] += 1
    numbers[i] = '{:06}{:06}'.format(p, counts[p])

for city in cities:
    print(numbers[city[0]])

### FIXED CODE ###

from collections import defaultdict
N, M = map(int, input().split())

counts = defaultdict(int)
numbers = {}

cities = []
for i in range(M):
    p, y = map(int, input().split())
    cities.append([i, p, y])

sorted_cities = sorted(cities, key=lambda x: x[2])
for city in sorted_cities:
    i, p, y = city
    counts[p] += 1
    numbers[i] = '{:06}{:06}'.format(p, counts[p])

for city in cities:
    print(numbers[city[0]])
from collections import defaultdict, deque
import sys
#input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
N = int(input())
A = sorted(inpl())

print(a[-1] - sum(map(abs, A[1:-1])) - A[0])
for i in range(N-2, 0, -1):
  a = A[i]
  if a > 0:
    print(A[0], a)
    A[0] -= a
    else:
      print(A[-1], a)
      A[-1] -= a
      print(A[-1], A[0])


### FIXED CODE ###

#!/usr/bin/env python3
import bisect
n = int(input())
a = sorted(map(int, input().split()))
if n == 2:
    print(a[1] - a[0])
    print(a[1], a[0])
    exit()

p = bisect.bisect_left(a, 0)
p = min(max(1, p), n - 1)
print(sum(a[p:]) - sum(a[:p]))
b = a[p - 1]
for i in range(p, n - 1):
    print(b, a[i])
    b -= a[i]
c = a[n - 1]
for i in range(p - 1):
    print(c, a[i])
    c -= a[i]
print(c, b)