Harryxun/stf_run huggingface dataset:
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

"""
A<Bとする。
C<Dの場合：
A～CとB~Dの間に"##"が無ければ達成できる.
C>Dの場合：
上記に加え、B~Cの間に"..."が存在すれば達成できる
"""

n,a,b,c,d = map(int,readline().split())
s = readline().rstrip().decode('utf-8')
a,b,c,d = a-1,b-1,c-1,d-1

flag = 1
space = 0
res = 0
rock = 0
for i in range(a,c+1):
	if s[i] == "#":
		rock += 1
	else:
		rock = 0
	if rock >= 2:
		flag = 0
for i in range(b,d+1):
	if s[i] == "#":
		rock += 1
	else:
		rock = 0
	if rock >= 2:
		flag = 0
if c > d:
	for i in range(b-1,c+2):
		if s[i] == ".":
			space += 1
		else:
			res = max(res,space)
			space = 0
	if res < 3:
		flag = 0


print("Yes" if flag else "No")


### FIXED CODE ###

import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0

"""
A<Bとする。
C<Dの場合：
A～CとB~Dの間に"##"が無ければ達成できる.
C>Dの場合：
上記に加え、B~Cの間に"..."が存在すれば達成できる
"""

n,a,b,c,d = map(int,readline().split())
s = readline().rstrip().decode('utf-8')
a,b,c,d = a-1,b-1,c-1,d-1

flag = 1
space = 0
res = 0
rock = 0
for i in range(a,c+1):
	if s[i] == "#":
		rock += 1
	else:
		rock = 0
	if rock >= 2:
		flag = 0
for i in range(b,d+1):
	if s[i] == "#":
		rock += 1
	else:
		rock = 0
	if rock >= 2:
		flag = 0
if c > d:
	for i in range(b-1,d+2):
		if s[i] == ".":
			space += 1
		else:
			res = max(res,space)
			space = 0
	res = max(res,space)
	if res < 3:
		flag = 0

print("Yes" if flag else "No")
import sys
input = sys.stdin.readline

from collections import deque
import copy
n,m = map(int,input().split())
r = [[] for i in range(n)]
for i in range(m):
    a,b,c = map(int,input().split())
    r[a-1].append((b-1,c,i+1))
    r[b-1].append((a-1,c,i+1))

def bfs(x,y):
    q = deque([])
    l = [-1]*n
    l[x] = 0
    check =[[] for i in range(n)]
    q.append((x,0,[]))
    while q:
        bef,pas,rec = q.popleft()
        if bef == y:
            break
            

        for nex,c,num in r[bef]:
            rec2 = copy.deepcopy(rec)
            rec2.append(num)
            
            if l[nex] == -1:
                l[nex] = pas+c
                check[nex] = rec2
                q.append((nex,pas+c,rec2))
            else:
                
                if pas+c < l[nex]:  
                    l[nex] = pas+c
                    check[nex] = rec2
                elif pas+c == l[nex]:
                    check[nex].append(rec2)
                else:
                    continue
    return check[y]

ans = set()
for i in range(n):
    for j in range(n):
        for k in bfs(i,j):
            ans.add(k)
        if len(ans) == m:
            print(0)
            exit()
print(m-len(ans))



            

### FIXED CODE ###

import heapq
n,m, = map(int,input().split())
E = [[] for i in range(n)]
for i in range(m):
    a,b,c = map(int,input().split())
    a -= 1
    b -= 1
    E[a].append((c,b))
    E[b].append((c,a))


def dijkstra(x):
    dis = [float("inf")]*n
    dis[x] = 0
    q = []
    heapq.heappush(q,(0,x))
    
    while q:
        cost,bef = heapq.heappop(q)

        if dis[bef] < cost:
            continue

        for ncost,nex in E[bef]:
            dist = ncost+cost

            if dist < dis[nex]:
                dis[nex] = dist
                heapq.heappush(q,(dist,nex))
    return dis

short = []
for i in range(n):
    short.append(dijkstra(i))
count = 0
for i in range(n):
    for dist,nex in E[i]:
        if short[i][nex] < dist:
            count += 1
print(count//2)
package main

import "fmt"

func main() {
    var a, b int
    fmt.Scan(&a, &b)
    if a*b%2 == 0 {
        fmt.Printf("Even\n")
    } else {
        fmt.Printf("Odd\n")
    }
}


### FIXED CODE ###

a = int(input())
s = raw_input().strip()

if a >= 3200:
    print s
else:
    print "red"
def dfs(v, g, color, paint=0):
	color[v] = paint
	for i in range(len(g)):
		if i == v:
			continue
		if color[i] != -1:
			continue
		if g[v][i]:
			np = paint if g[v][i] % 2 == 0 else 1 - paint
			dfs(i, g, color, np)

def resolve():
	n = int(input())
	color = [-1]*n
	g = [[-1]*n for _ in range(n)]
	for _ in range(n-1):
		u, v, w = map(int, input().split())
		g[u-1][v-1] = w
		g[v-1][u-1] = w
	for v in range(n):
		if color[v] > -1:
			continue
		dfs(v, g, color)

	for i in color:
		print(i)

resolve()

### FIXED CODE ###

import sys
sys.setrecursionlimit(100**4)

class Edge():
	def __init__(self, v, w):
		self._v = v
		self._w = w
	def v(self):
		return self._v
	def w(self):
		return self._w

def dfs(v, g, colors, color = 0):
	colors[v] = color
	if not len(g[v]):
		return
	for nv in g[v]:
		if colors[nv.v()] != -1:
			continue
		nc = color if nv.w() % 2 == 0 else 1 - color
		dfs(nv.v(), g, colors, nc)

def resolve():
	n = int(input())
	colors = [-1]*n
	g = [list() for _ in range(n)]
	for _ in range(n-1):
		u, v, w = map(int, input().split())
		g[v-1].append(Edge(u-1, w))
		g[u-1].append(Edge(v-1, w))
	for i in range(n):
		if colors[i] != -1:
			continue
		dfs(i, g, colors)
	for c in colors:
		print(c)
resolve()
N, A, B = map(int, input().split())
S = input()
a = 0
b = 0
for i in range(S):
  if S[i] == 'a' and a+b < A+B:
    a += 1
    print('Yes')
  elif S[i] == 'b' and a+b < A+B and b < B:
    print('Yes')
  else:
    print('No')

### FIXED CODE ###

N, A, B = map(int, input().split())
S = input()
a = 0
b = 0
for i in range(N):
  if S[i] == 'a' and a+b < A+B:
    a += 1
    print('Yes')
  elif S[i] == 'b' and a+b < A+B and b < B:
    b += 1
    print('Yes')
  else:
    print('No')
import random

n = input()
n = int(n)

if n == 0:
	print(0)

elif n == 1:
	_ = input()
	print(0)

else:
	h = []

	for i in range(n):
		h.append(int(input()))

	rnd = random.randint(0, n)
	count = 0

	for i in range(rnd, n-1):
		if h[i+1] <= h[i]:
			count += 1

	print(count)

### FIXED CODE ###

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

count = 0
count_list = [0]

for i in range(n-1):
	if(h[i+1] <= h[i]):
		count += 1
		count_list.append(count)
	else:
		count = 0

print(max(count_list))
N, M = map(int,input().split())
A = list(map(int,input().split()))
A.sort(reverse=True)
S = sum(A)
if A[M-1] >= S / (4*M):
print("Yes")
else:
print("No")

### FIXED CODE ###

N, M = map(int,input().split())
A = list(map(int,input().split()))
A.sort(reverse=True)
S = sum(A)
if A[M-1] >= S / (4*M):
	print("Yes")
else:
	print("No")
x, y = map(int, input().split())
if (x+y)%3 != 0:
    print(0)
    exit()

a = (2*x - y)//3
b = (-x + 2*y)//3
if a < 0 or b < 0:
    print(0)
    eixt()

MOD = 10**9+7
MAX_N = 10**6
fact = [1]
fact_inv = [0]*(MAX_N+4)
for i in range(MAX_N+3):
    fact.append(fact[-1]*(i+1)%MOD)

fact_inv[-1] = pow(fact[-1],MOD-2,MOD)
for i in range(MAX_N+2,-1,-1):
    fact_inv[i] = fact_inv[i+1]*(i+1)%MOD

def mod_comb_k(n,k,MOD):
    return fact[n] * fact_inv[k] % MOD * fact_inv[n-k] %MOD


print(mod_comb_k(a+b, a, MOD))

### FIXED CODE ###

x, y = map(int, input().split())
if (x+y)%3 != 0:
    print(0)
    exit()

a = 2*x - y
b = -x + 2*y
if a < 0 or b < 0:
    print(0)
    exit()

a //= 3
b //= 3
MOD = 10**9+7
MAX_N = 10**6
fact = [1]
fact_inv = [0]*(MAX_N+4)
for i in range(MAX_N+3):
    fact.append(fact[-1]*(i+1)%MOD)

fact_inv[-1] = pow(fact[-1],MOD-2,MOD)
for i in range(MAX_N+2,-1,-1):
    fact_inv[i] = fact_inv[i+1]*(i+1)%MOD

def mod_comb_k(n,k,MOD):
    return fact[n] * fact_inv[k] % MOD * fact_inv[n-k] %MOD


print(mod_comb_k(a+b, a, MOD))
n = int(input())
c = []
for i in range(n):
    k = []
    for j in range(i):
        if i % j == 0:
            k.append(j)
    if len(k) == 8:
        c.append(i)
print(len(c))

### FIXED CODE ###

N = int(input())
if N >= 195:
    print(5)
elif N >= 189:
    print(4)
elif N >= 165:
    print(3)
elif N >= 135:
    print(2)
elif N >= 105:
    print(1)
else:
    print(0)
a,b,c=map(int, input.split())
print(z,x,y)

### FIXED CODE ###

x,y,z=map(int,input().split())
print(str(z)+" "+str(x)+" "+str(y))
NM = list(map(int, input().split()))
N, M = NM[0],NM[1]
a = list(map(int, input().split()))

if  sum(a)> N:
    print(-1)
else:
    print(N - sum(A))

### FIXED CODE ###

N, M = input().split()
N, M = [int(N), int(M)]
a = list(map(int, input().split()))

for i in range(M):
    N -= a[i]

if N < 0:
    print(-1)
else:
    print(N)
from collections import Counter
S = str(input())
SC = Counter(S)
v,c = zip(*SC.most_common())
print(len(S) - abs(c[1]-c[0]))

### FIXED CODE ###

S = str(input())
zero = 0
one = 0
for i in S:
  if i == "0":
    zero += 1
  else:
    one += 1
ans = min(zero,one)*2
print(ans)
N = int(input())
s = [input() for i in range(N)] #複数行の数値の入力を取得
c = collections.Counter(s)
print(c)

### FIXED CODE ###

from collections import Counter
N = int(input())
s = [input() for i in range(N)]
c = Counter(s)
print(len(c))
import collections
N=int(input())
A=list(map(int,input().split()))
if N%2==1:
    if 0 not in A:
        print(0)
    else:
        B=A.remove(0)
        Bc=dict(collections.Counter(B))
        for i in Bc.keys():
            if Bc[i]!=2:
                print(0)
                break
        else:
            print(2**(B//2)%(10**9+7))
else:
    Bc=dict(collections.Counter(A))
    for i in Bc.keys():
        if Bc[i]!=2:
            print(0)
            break
    else:
        print(2**(B//2)%(10**9+7))            

### FIXED CODE ###

import collections
N=int(input())
A=list(map(int,input().split()))
if N%2==1:
    if 0 not in A:
        print(0)
    else:
        A.remove(0)
        Bc=dict(collections.Counter(A))
        for i in Bc.keys():
            if Bc[i]!=2:
                print(0)
                break
        else:
            print((2**(len(A)//2))%(10**9+7))
else:
    Bc=dict(collections.Counter(A))
    for i in Bc.keys():
        if Bc[i]!=2:
            print(0)
            break
    else:
        print((2**(len(A)//2))%(10**9+7))
S = input()
K = int(input())

if K > 100:
    print(S[0])
else:
    for i in range(K + 1):
        if S[i] != "1":
            print(S[i])
            break
        if i == K:
            print(S[K])

### FIXED CODE ###

S = input()
K = int(input())


for i in range(K):
    if S[i] != "1":
        print(S[i])
        break
    if i == K-1:
        print(S[K-1])
N = int(input())
pt, px, py = 0, 0, 0

for i in range (N):
    t, x, y = map(int, input().split())
    dt = t - pt
    dxy = x-px+y-py
    if dxy > dt or dxy%2 != dt%2:
        print("No")
        exit()
    pt, px, py = x, y, z
print("Yes")

### FIXED CODE ###

n = int(input())
a,b,c=0,0,0
for i in range(n):
    t,x,y = map(int, input().split())
    sa = t-a
    if sa<abs(x-b)+abs(y-c):
        print("No")
        exit()
    else:
        tw = sa-abs(x-b)-abs(y-c)
        if tw%2!=0:
            print("No")
            exit()
    a,b,c=t,x,y
print("Yes")
from numpy import *;i=int32;p=input;q=searchsorted;N=int(p());A=i(p().split());B=i(p().split());c=0;
for k in range(1,30):
  a,b=sort(hstack((A%(1<<k),A%(1<<k)-2**k))),B%(1<<k);c+=((sum(q(a,2**k-b)-q(a,2**(k-1)-b)))&1)<<k-1
print(c)


### FIXED CODE ###

#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
import numpy as np
sys.setrecursionlimit(10**5)
stdin = sys.stdin
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007

#A
def A():
    a, b, c = LI()
    if a + b >= c:
        print("Yes")
    else:
        print("No")
    return

#B
def B():
    return

#C
def C():
    n = II()
    ab = LIR(n)
    cd = LIR(n)
    ab.sort()
    cd.sort()
    check = [0 for i in range(n)]
    ans = 0
    #print(ab)
    for _, c in enumerate(cd):
        d = c[1]
        c = c[0]
        maxy = -1
        x = -1
        for k, a in enumerate(ab):
            b = a[1]
            a = a[0]
            if maxy < b and c > a and check[k] == 0 and d > b:
                maxy = b
                x = k
                #print(a,b,c,d)
        if x != -1:
            ans += 1
            check[x] += 1
    print(ans)


    return

#D
def D():
    N = II()
    a = LI()
    b = LI()
    ans = 0
    for i in range(29):
        t = 2 ** i
        a2 = [A % (2 * t) for A in a]
        b2 = [B % (2 * t) for B in b]
        a2.sort()
        b2.sort()
        ansb = 0
        for A in a2:
            ansb += np.searchsorted(b2, 2 * t - A) - np.searchsorted(b2, t - A)
            ansb += N - np.searchsorted(b2, 3* t - A)
            #print(ansb)
        #ans += (ansb % 2) << i
        ans += ((ansb %2 ) << i)
    print(ans)
    return

#E
def E():
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == '__main__':
    A()
N = int(input())
count = 1+N
for i in range(1,N/2 +1):
  if N % i == 0 and i + N/i < count:
    count = i+ N/i
count = int(count)
print(count-2)


### FIXED CODE ###

N = int(input())
count = 1+N
for i in range(1,int(N**0.5)+1):
  if N % i == 0 and i + N/i < count:
    count = i+ N/i
count = int(count)
print(count-2)
N=int(input())
for h in range(1,3501):
  for n in range(1,3501):
    w=(N*h*n)/(4*h*n-N*(h+n))
    if w%1==0:print(h,n,int(w));exit()


### FIXED CODE ###

N=int(input())
for h in range(1,3501):
  for n in range(1,3501):
    if 1/h+1/n>=4/N:continue
    w=(N*h*n)/(4*h*n-N*(h+n))
    if w==int(w):print(h,n,int(w));exit()
import sys

n=int(input())
for _ in range(n):
    a=input()
    b=input()
    c=input()


cnt = 0
for i in range(n):
    if a[i] == b[i] == c[i]:
        continue
    elif a[i] == b[i] or b[i] == c[i] or c[i] == a[i]:
        cnt = cnt + 1
    else:
        cnt = cnt + 2
print(cnt)

### FIXED CODE ###

import sys

n=int(sys.stdin.readline())
a=sys.stdin.readline()
b=sys.stdin.readline()
c=sys.stdin.readline()


cnt = 0
for i in range(n):
    if a[i] == b[i] == c[i]:
        continue
    elif a[i] == b[i] or b[i] == c[i] or c[i] == a[i]:
        cnt = cnt + 1
    else:
        cnt = cnt + 2
print(cnt)
import sys
n=int(input())
a=list(map(int,input().split()))

if n==1:
    print(0)
    sys.exit()

def abs(a):
    if a<0:
        return -a
    else:
        return a

for i in range(n):
    a[i]=a[i]-i-1

ans=10**12
a.sort()
if n<50:
    for b in a:
        S=0
        for j in range(n):
            S+=abs(a[j]-b)
        ans=min(ans,S)
    if ans==10**12:
        ans=0
    print(ans)
    sys.exit()

mid=n//2
if a[mid]<0:
    b_choice=a[mid-20:mid]
else:
    b_choice=a[mid:mid+20]
for b in range(b_choice):
    S=0
    for j in range(n):
        S+=abs(a[j]-b)
    ans=min(ans,S)
if ans==10**12:
    ans=0
print(ans)

### FIXED CODE ###

n=int(input())

if n%2==0:
    print(n)
else:
    print(2*n)
ls =list([2,4,5,7,9],[0,1,6,8],[3])
dic = dict{[2,4,5,7,9]:"hon" , [0,1,6,8]:"pon" , [3]:"bon"}
s=int(input())
for i in ls:
  if s%10 in i:
    print(dic[i])

### FIXED CODE ###

ls =["24579" , "0168" , "3"]
dic = {"24579":"hon" , "0168":"pon" , "3":"bon"}
s=input()
for i in ls:
  if s[len(s)-1] in i:
    print(dic[i])
N = int(input())
A = list(map(int, input().split()))
cnt = 0
from collections import Counter

if A.most_common[0][1] <= 1:
	print('YES')
else:
	print('NO')

### FIXED CODE ###

N = int(input())
A = list(map(int, input().split()))
cnt = 0
from collections import Counter
B=Counter(A)
C=B.most_common()
if C[0][1] <= 1:
	print('YES')
else:
	print('NO')
N = input()
M = int(N**0.5//1)
S = list()
for i in range(M+1):
    if i > 0 :
       if N%i == 0:
           S.append(i)
a =  S[-1]
b = N//a
print(len(str(a))+len(str(b)))

### FIXED CODE ###

import math

N = int(input())
M = int(N**0.5//1)
S = list()
for i in range(M+1):
    if i > 0 :
       if N%i == 0:
           S.append(i)
a =  S[-1]
b = N//a
print(max(len(str(a)),len(str(b))))
N, M = map(int, input().split())
KS = []*M
for i in range(M):
  KS[i]= list(map(int, input().split()))
P = list(map(int, input().split()))

ans = 0
for i in range(N**2):
  sl = []
  for j in range(N):
    if (i>>j)&1:
      sl.append(j+1)
  for j in range(M):
    if len(set(KS[j][1:])&set(sl))%2 ==P[j]:
      continue
    else:
      break
  else:
    ans += 1
    
print(ans)
    

### FIXED CODE ###

N, M = map(int, input().split())
KS = [[] for i in range(M)]
for i in range(M):
  KS[i]= list(map(int, input().split()))
P = list(map(int, input().split()))

ans = 0
for i in range(2**N):
  sl = []
  for j in range(N):
    if (i>>j)&1:
      sl.append(j+1)
  for j in range(M):
    if len(set(KS[j][1:])&set(sl))%2 ==P[j]:
      continue
    else:
      break
  else:
    ans += 1
    
print(ans)
a,b,c,k=map(int,input().split())
max_value=0
if k=<a+b:
  max_value=a
elif a+b<k=<a+b+c:
  max_value=a-k+a+b
print(max_value)

### FIXED CODE ###

a,b,c,k=map(int,input().split())
if a<=k<=a+b:
  max_value=a
elif k<a:
	max_value=k
else:
  max_value=a*2-k+b
print(max_value)
n=int(input())
k=int(input())
N=map(int,input().split())
count=0
for n1 in n:
  if N>k:
    count+=1
  ekse:
    print(0)
pribt(count)


### FIXED CODE ###

N, K = map(int, input().split())
h = list(map(int, input().split()))
count = 0
for i in h:
    if i >= K:
      count+=1
print(count)
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
tot = sum(B)
for i in range(n-1):
  if A[i+1] == A[i]+1:
    tot += C[A[i]]
print(tot)

### FIXED CODE ###

n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
tot = sum(B)
for i in range(n-1):
  if A[i+1] == A[i]+1:
    tot += C[A[i]-1]
print(tot)
tiles = map(int, input())
# inputs = "10010010"
# tiles = list(map(int, inputs))


def count_repaint_tiles(tiles):
    if len(tiles) == 0:
        return 0
    counts = 0
    color = tiles[0]
    for tile in tiles[1:]:
        counts = counts + 1 if tile != color else 0
        color = 1 - color
    return counts


print(count_repaint_tiles(tiles))


### FIXED CODE ###

tiles = list(map(int, input()))
# inputs = "10010010"
# tiles = list(map(int, inputs))


def count_repaint_tiles(tiles):
    if len(tiles) == 0:
        return 0
    counts = 0
    color = tiles[0]
    for tile in tiles[1:]:
        if tile == color:
            counts = counts + 1
        color = 1 - color
    return counts


print(count_repaint_tiles(tiles))
# coding: utf-8
def is_easy(steps):
  for i, step in enumerate(steps):
    if i % 2 == 0 and step == 'L':
      return 'No'
  	elif i % 2 == 1 and step == 'R':
      return 'No'
	return 'Yes'
  
steps = input()
print(is_easy(steps))

### FIXED CODE ###

# coding: utf-8
def is_easy(steps):
    for i, step in enumerate(steps):
        if i % 2 == 0 and step == 'L':
            return 'No'
        elif i % 2 == 1 and step == 'R':
            return 'No'
    return 'Yes'
  
steps = input()
print(is_easy(steps))
D,T,S=map(int,input())
if D*S>T :
 print("No")
else:
 print("Yes")

### FIXED CODE ###

D,T,S=map(int,input().split())
if (D/S)>T:
	print("No")
else:
	print("Yes")
from math import gcd

N = int(input())

t = int(input())
ans = t
for _ in range(N - 1):
    tmp = int(input())
    t = gcd(ans, tmp)
    ans *= tmp
    ans //= t

print (ans)

### FIXED CODE ###

N = int(input())

def gcd(x, y):
    if x > y:
        x, y = y, x
    if y % x == 0:
        return x
    else:
        return gcd (y%x, x)


T1 = int(input())
ans = T1
for i in range(N-1):
    T2 = int(input())
    ans = T1 * T2 //gcd(T1, T2)
    T1 = ans

print (ans)

# print (gcd(12, 8))
S = input()
T = input()
print(T + S)

### FIXED CODE ###

inputStrings = input().split()
print(inputStrings[1] + inputStrings[0])
import numpy as np
import sys

for i in sys.stdin:
    a,b,c,d,e,f = map(float, i.split())
    A = np.array([[ a, b],
        [ d, e]])
    B = np.array([c,f])
    X = np.linalg.solve(A,B)
    print "{0:.3f}".format(X[0]),"{0:.3f}".format(X[1])

### FIXED CODE ###

import sys
 
out = []
for line in sys.stdin.readlines():
    List = map(float, line.strip().split())
 
    [a, b, c, d, e, f] = List
 
    x = (b*f-c*e)/(b*d-a*e)
    y = (a*f-c*d)/(a*e-b*d)
 
    out.append("%.3f %.3f" % (x+0, y+0))
 
for i in xrange(len(out)):
    print out[i]
#!/usr/bin/env python3
import sys


def hadEnd(dp):
    lastCol = dp[len(dp) - 1]
    for c in lastCol:
        if c != 0:
            return False
    return True


def dfs(cand, N, c):
    nextBase = c * 10
    result = 0
    for can in cand:
        next = nextBase + can[0]
        if(N - can[1] == 0):
            result = max(result, next)
            continue
        elif(N - can[1] < 0):
            result = max(result, -1)
            continue
        result = max(result, dfs(cand, N - can[1], next))
    return result


def solve(N: int, M: int, A: "List[int]"):
    costs = [10**18, 2, 5, 5, 4, 5, 6, 3, 7, 6]
    cand = [(i, costs[i]) for i in A]
    print(dfs(cand, N, 0))
    return


# Generated by 1.1.3 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    M = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(M)]  # type: "List[int]"
    solve(N, M, A)


if __name__ == '__main__':
    main()


### FIXED CODE ###

#!/usr/bin/env python3
import sys


def solve(N: int, M: int, A: "List[int]"):
    costs = [10**18, 2, 5, 5, 4, 5, 6, 3, 7, 6]
    cand = [(i, costs[i]) for i in A]
    cand.sort(reverse=True)
    digits = [-1 * 10**16 for i in range(N+1)]
    digits[0] = 0
    for i in range(1, N+1):
        r = -1 * 10**16
        for c in cand:
            if i - c[1] >= 0:
                r = max(r, digits[i - c[1]] + 1)
        digits[i] = r
    digit = digits[N]
    lastCost = N
    result = 0
    # print(digits)
    for i in range(digit):
        for c in cand:
            if lastCost - c[1] >= 0 and digits[lastCost - c[1]] == digits[lastCost] - 1:
                result = result*10 + c[0]
                lastCost = lastCost - c[1]
                # print(f"lastCost:{lastCost} result:{c[0]} cost:{c[1]}")
                break
    print(result)
    return


# Generated by 1.1.3 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    M = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(M)]  # type: "List[int]"
    solve(N, M, A)


if __name__ == '__main__':
    main()