Harryxun/stf_run huggingface dataset:
n, k = map(int, input().split())
if n <= k:
  print(1)
else:
  c = n // k
  ans = 1
  while (c >= 1):
    ans += 1
    c = c // k
print(ans)
    

### FIXED CODE ###

n, k = map(int, input().split())
if n < k:
  print(1)
else:
  c = n // k
  ans = 1
  while (c >= 1):
    ans += 1
    c = c // k
  print(ans)
import comb

A = int(input())*500//50
B = int(input())*100//50
C = int(input())*50//50
X = int(input())//50

#Aが最大何ユニット使えるかを調べる

if A == 0:
	Max_A = 0

else:
	Max_A = X // 10


counter = 0
# H = 0

for i in range(Max_A + 1):
	res_X = X - 10*i
	## B, Cだけで埋めていく
	if B == 0:
		Max_B = 0
	else:
		Max_B = res_X // 2
	for  j in range(min(Max_B + 1, B//2 + 1)):
		res_X = X - 10*i - 2*j

		# print(Max_A,Max_B,i,j,res_X,C, res_X <= C)
		# H += 1

		if res_X <= C:
			counter += 1
		# # if res_X > C:
		# # 	continue
		# # #二項係数の計算　Aのユニット数はA//10　Bのユニット数はB//10　Cはそのまま
		# # else:
		# 	counter += 1
		# 	# counter += comb.comb(A//10, i)*comb.comb(B//2, j)*comb.comb(C, res_X)
			# print(comb.comb(A//10, i)*comb.comb(B//2, j)*comb.comb(C, res_X), 
				# comb.comb(A//10, i), comb.comb(B//2, j), comb.comb(C, res_X))


print(int(counter))
# print(H)


### FIXED CODE ###

A = int(input())
B = int(input())
C = int(input())
X = int(input())

counter = 0

N_maxA = min( int(X // 500), A )

for i in range(N_maxA + 1):
	Res = X - (i * 500)
	N_maxB = min( int(Res // 100) , B )
	
	for j in range(N_maxB + 1):
		Res1 = Res - j*100
		if int(Res1 // 50) <= C:
			
			counter += 1

print(counter)
def compression(init, matrix):
	
	mir = []
	
	for row in matrix:
		if "#"in row:
			mir.append(row)
	matrix = []
	
	mir = list(map(list, zip(*mir)))
	
	for row in mir:
		if "#"in row:
			matrix.append(row)
		
	matrix = list(map(list, zip(*matrix)))	
			
	
	return matrix


init = input().split(" ")
init = [int(c) for c in init]

matrix = [[] for j in range(init[0])]
j = 0

for j in range(init[1]+1):
	matrix[j] = input()

result = compression(init, matrix)
for row in result:
	print("".join(row))

### FIXED CODE ###


def compression(init, matrix):
	
	mir = []
	
	for row in matrix:
		if "#"in row:
			mir.append(row)
	matrix = []
	
	mir = list(map(list, zip(*mir)))
	
	for row in mir:
		if "#"in row:
			matrix.append(row)
		
	matrix = list(map(list, zip(*matrix)))	
			
	
	return matrix


init = input().split(" ")
init = [int(c) for c in init]

matrix = [[] for j in range(init[0])]

for j in range(init[0]):
	matrix[j] = input()

result = compression(init, matrix)
for row in result:
	print("".join(row))
import math
A,B,C,D = map(int,input().split())
bi = C*D/math.gcd(D,C)
A-=1
Bbi =B//bi
Abi =A//bi
sa = Bbi -Abi
Bc = B//C
Bd = B//D
Ac = A//C
Ad = A//D
print(int( B-A - ((Bc-Ac) + (Bd-Ad) - sa)  ))

### FIXED CODE ###

import fractions

A,B,C,D = map(int,input().split())

# CとDの最小公倍数算出
bi = C*D//fractions.gcd(D,C)

A-=1
Bbi =B//bi
Abi =A//bi
sa = Bbi -Abi
# print(B-A-sa)

Bc = B//C
Bd = B//D

Ac = A//C
Ad = A//D

print(int( B-A - ((Bc-Ac) + (Bd-Ad) - sa)  ))
from math import atan,pi
a,b,x=map(int,input().split())
if a**2*b>=2*x:
    print(90-atan(2*x/(a*b**2))*180/pi)
else:
    print(90-atan(a**3/(2*a**2*b-2*x))*180/pi)


### FIXED CODE ###

from math import atan,pi
a,b,x=map(int,input().split())
if a**2*b>=2*x:
    try:
        print(90-atan(2*x/(a*b**2))*180/pi)
    except: print(0)
else:
    try:
        print(90-atan(a**3/(2*a**2*b-2*x))*180/pi)
    except: print(0)
s = input()
t = input()
s.sort()
t.sort()
t.reverse()
if s < t:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

s = list(input())
t = list(input())
s.sort()
t.sort()
t.reverse()
s = ''.join(s)
t = ''.join(t)
if s < t:
  print('Yes')
else:
  print('No')
k, n = map(int, input().split())
house_list = list(map(int, input().split()))
for i in range(n):
  house_list.append(house_list[i] - k)
tmp_list = sorted(house_lise)
ans_list = []
for j in range(n + 1):
  ans_list.append(tmp_list[j + n - 1] - tmp_list[j])
print(min(ans_list)

### FIXED CODE ###

k, n = map(int, input().split())
house_list = list(map(int, input().split()))
for i in range(n):
  house_list.append(house_list[i] - k)
tmp_list = sorted(house_list)
ans_list = []
for j in range(n + 1):
  ans_list.append(tmp_list[j + n - 1] - tmp_list[j])
print(min(ans_list))
k=input()

ln=[1,2,3,4,5,6,7,8,9]
old=0
new=9
while len(ln)<100:
    for i in xrange(old, new):
        if ln[i]%10!=9:
            ln.append(ln[i]*10+ln[i]%10-1)
            ln.append(ln[i]*10+ln[i]%10)
            ln.append(ln[i]*10+ln[i]%10+1)
        else:
            ln.append(ln[i]*10+ln[i]%10-1)
            ln.append(ln[i]*10+ln[i]%10)
    old=new
    new=len(ln)

ln.sort()
print ln[k-1]

### FIXED CODE ###

k=input()

ln=[1,2,3,4,5,6,7,8,9]
i=0
while len(ln)<100001:
    if ln[i]%10==0:
        ln.append(ln[i]*10)
        ln.append(ln[i]*10+1)
    elif ln[i]%10!=9:
        ln.append(ln[i]*10+ln[i]%10-1)
        ln.append(ln[i]*10+ln[i]%10)
        ln.append(ln[i]*10+ln[i]%10+1)
    else:
        ln.append(ln[i]*10+8)
        ln.append(ln[i]*10+9)
    i+=1

# print ln
# print ln[9]
print ln[k-1]
N, K = map(int, input().split())
p_list = list(map(int, input().split()))

p_list_E = []
p_list_E_temp = [1, 1.5, 2, 2.5, 3, 3.5]

for i in range(len(p_list)):
    p_list_E.append(p_list_E_temp[p_list[i]-1])
#print(p_list_E)

p_list_sum = [0]
for i in range(0,N):
    p_list_sum.append(p_list_sum[i]+p_list_E[i])
#print(p_list_sum)

ans = 0
for i in range(K,N+1):
    ans = max(ans, p_list_sum[i]-p_list_sum[i-K])
print(ans)

### FIXED CODE ###

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

p_list_E = []
p_list_E_temp = [1, 1.5, 2, 2.5, 3, 3.5]

for i in range(len(p_list)):
    p_list_E.append((p_list[i]+1)*0.5)
#print(p_list_E)

p_list_sum = [0]
for i in range(0,N):
    p_list_sum.append(p_list_sum[i]+p_list_E[i])
#print(p_list_sum)

ans = 0
for i in range(K,N+1):
    ans = max(ans, p_list_sum[i]-p_list_sum[i-K])
print(ans)
mod = 10**9+7

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

remain = 3
s = [0,0,0]
ans = 1
for i in a:
    ans *= s.count(i)
    ans %= mod
    s[s.index(i)] += 1

print(ans)

### FIXED CODE ###

mod = 10**9+7

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

remain = 3
s = [0,0,0]
ans = 1
for i in a:
    k = s.count(i)
    ans *= s.count(i)
    ans %= mod
    if k == 0:
        break
    s[s.index(i)] += 1

print(ans)
import sys

for line in sys.stdin:
    N = int(line)
    found=False
    for i in range(1, 10, 1): 
        if N % i == 0 and N // i <= 9:
            found = True
            break
    if found:
        print('Yes')
    else:
        print('No')

### FIXED CODE ###

import sys

for line in sys.stdin:
    A, B = list(map(int, line.split(' ')))


    if 1 <= A <= 9 and 1 <= B <= 9:
        out = A*B
        print(out)
    else:
        print(-1)
n=input()
print(n*(n+1)//2)

### FIXED CODE ###

n=int(input())
print(n*(n+1)//2)
l = map(int,raw_input().split())
print(l[0] * l[1], l[0] * 2 + l[1] * 2)

### FIXED CODE ###

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

s = a * b
shu = a * 2 + b * 2
fmt = "{s} {shu}"
s = fmt.format(s = s,shu = shu)
print(s)
S=input()
if S[3]==S[4] and S[5]==S[6]:
    print('Yes')
else:
    print('No')


### FIXED CODE ###

S=input()
if S[2]==S[3] and S[4]==S[5]:
    print('Yes')
else:
    print('No')
n,m = map(int,input().split())
h = list(map(int,input().split()))
r = []
cnt = 0

for i in range(m):
    i = list(map(int,input().split()))
    r.append(i)

r = [e for row in r for e in row]

for i in range(n):
    flag = 0
    for j in range(0,m,2):
        if h[i] == h[r[j]]:
            if h[i] < h[r[j+1]]:
                flag += 1
                break
        elif h[i] == h[r[j+1]]:
            if h[i] < h[r[j]]:
                flag += 1
                break
    if flag == 0:
        cnt += 1

print(cnt)

### FIXED CODE ###

n,m = map(int,input().split())
h = list(map(int,input().split()))
ans = 0
memo = [0]*n
 
for _ in range(m):
    a,b = map(int,input().split())
    a -= 1
    b -= 1
    if memo[a] < h[b]:
        memo[a] = h[b]
    if memo[b] < h[a]:
        memo[b] = h[a]

for i in range(n):
    if memo[i] < h[i]:
        ans += 1

print(ans)
while True:
(a, op, b) = [int(i) if i.isdigit() else i for i in input().split()]

if op == '?':
    break
elif op =='+':
    print(a + b)
elif op == '-':
    print(a - b)
elif op == '*':
    print(a * b)
else op == '/':
    print(a // b)

### FIXED CODE ###

while True:
    (a, op, b) = [int(i) if i.isdigit() else i for i in input().split()]
    if op == '?':
        break
    elif op =='+':
        print(a + b)
    elif op == '-':
        print(a - b)
    elif op == '*':
        print(a * b)
    elif op == '/':
        print(a // b)
import heapq
def solve():
  x1,y1,x2,y2 = (int(i) for i in input().split())
  
  que = []
  que2 = []
  for i in range(-300,300):
    for j in range(-300,300):
      if (x2-x1)**2+(y2-y1)**2 == (i-x1)**2+(j-y1)**2:
        if (i,j) != (x1,y1) and  (i,j) != (x2,y2):
          que.append((i,j))
      if (x2-x1)**2+(y2-y1)**2 == (i-x2)**2+(j-y2)**2:
        if  (i,j) != (x1,y1) and  (i,j) != (x2,y2):
         que2.append((i,j))
        
  #define x3,y3
  while que2:
    (x3,y3) = heapq.heappop(que2)
    for i in range(len(que)):
      x4,y4 = que[i]
      if (x3-x2)**2+(y3-y2)**2 == (x4-x1)**2+(y4-y1)**2:
       if (x3-x4)**2+(y3-y4)**2 == (x2-x1)**2+(y2-y1)**2:
        if (x3-x1)**2+(y3-y1)**2 == (x2-x4)**2+(y2-y4)**2:
           print(x3,y3,x4,y4)
            exit()
  #print(que)
 #print(que2)			
solve()

### FIXED CODE ###

import heapq
def solve():
  x1,y1,x2,y2 = (int(i) for i in input().split())
  x = x2-x1
  y = y2-y1
  print(x2-y,y2+x,x1-y,y1+x)
 	
solve()
k = int(input())
b = 7
c = 1
a = []
e = 0
a.append(7)
if(k%2 == 0):
  print(-1)
else:
  while(b%k != 0):
    r = b%k
    b = 10*r+7
    c += 1
    if b in a:
      e = 1
  	a.append(b)
  if(e == 1):
    print(-1)
  else:
  	print(c)

  


### FIXED CODE ###

k = int(input())
n = 7
c = 1
if(k%2 == 0):
  print(-1)
else:
  while(True):
    if(n%k == 0):
      break
    if(c > k):
      c = -1
      break
    r = n%k
    n = 10*r+7
    c += 1
  print(c)
A = input()
B = input()
C = input()
if A == B != C :
  print('Yes')
elif A != B == C :
  print('Yes')
elif A == C != B :
  print('Yes')
else :
  print('No')


### FIXED CODE ###

i = list(map(int, input().split()))
A = i[0]
B = i[1]
C = i[2]
if A == B != C :
  print('Yes')
elif A != B == C :
  print('Yes')
elif A == C != B :
  print('Yes')
else :
  print('No')
# import bisect
# import heapq
# from copy import deepcopy
# from collections import deque
# from collections import Counter
# from itertools import accumulate
# from itertools import permutations
# import numpy as np
# import math

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

class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def size(self, x):
        return -self.parents[self.find(x)]

uf = UnionFind(n)
friend =[[] for _ in range(n)]
block = [[] for _ in range(n)]
for i in range(m):
    a,b = map(int, input().split())
    a,b = a-1,b-1
    uf.union(a,b)
    friend[a].append(b); friend[b].append(a)

for i in range(k):
    c,d = map(int, input().split())
    c,d = c-1,d-1
    if uf.same(c,d):
        block[c].append(d); block[d].append(c)

w = [0] * n
for i in range(n):
    w[i] = uf.size(i) - len(friend[i]) - len(block[i]) - 1

print(*w)

### FIXED CODE ###

# import bisect
# # import heapq
# # from copy import deepcopy
from collections import deque
# # from collections import Counter
# # from itertools import accumulate
# # from itertools import permutations
# import numpy as np
# # import math

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

class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def size(self, x):
        return -self.parents[self.find(x)]

uf = UnionFind(n)
friend =[[] for _ in range(n)]
block = [[] for _ in range(n)]
for i in range(m):
    a,b = map(int, input().split())
    a,b = a-1,b-1
    uf.union(a,b)
    friend[a].append(b); friend[b].append(a)

for i in range(k):
    c,d = map(int, input().split())
    c,d = c-1,d-1
    if uf.same(c,d):
        block[c].append(d); block[d].append(c)

w = [0] * n
for i in range(n):
    w[i] = uf.size(i) - len(friend[i]) - len(block[i]) - 1

print(*w)
n,m,k = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))

count = 0

for i in zip(a,b):
  count += min(a[i],b[i])
  if count > k:
    break
    
print(k // count)


### FIXED CODE ###

a = int(input())

print(a + a ** 2 + a ** 3)
number = raw_input()
print(number **3)

### FIXED CODE ###

num = int(input())
number = num **3
print(number)
S = input()
k = int(input())
if len(S)<=k:
  print(S)
else:
  print(S[:k]+"...")
 


### FIXED CODE ###

k = int(input())
S = input()

if len(S)<=k:
  print(S)
else:
  print(S[:k]+"...")
import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)

H, W = map(int, input().split())
field = ['' for _ in range(H)]
seen = [[False for _ in range(W)] for _ in range(H)]
seen_black = [[False for _ in range(W)] for _ in range(H)]

dx = [0, 1]
dy = [1, 0]
stop = (0, 0)
next_start = (0,0)
def dfs(h, w):
    global stop
    seen[h][w] = True
    for dir in range(2):
        nh = h + dx[dir]
        nw = w + dy[dir]
        
        if nh < 0 or nh >= H or nw < 0 or nw >= W:
            continue
        if field[nh][nw] == '#':
            if nh < stop[0] or nw < stop[0]:continue
            if nh+nw > stop[0]+stop[1]:
                stop = (nh, nw)
            elif nh+nw == stop[0]+stop[1]:
                if stop[0] < nw and field[nh][nw:].count(".") > field[nh:][nw].count("."):
                    stop = (nh, nw)
                if stop[1] < nh and field[nh][nw:].count(".") < field[nh:][nw].count("."):
                    stop = (nh, nw)
            continue
        if seen[nh][nw] == True:
            continue
        dfs(nh, nw)
def dfs_black(h, w):
    global next_start
    seen_black[h][w] = True
    for dir in range(2):
        nh = h + dx[dir]
        nw = w + dy[dir]
        
        if nh < 0 or nh >= H or nw < 0 or nw >= W:
            continue
        if field[nh][nw] == '.':
            if nh < next_start[0] or nw < next_start[0]:continue
            if nh+nw > next_start[0]+next_start[1]:
                next_start = (nh, nw)
            continue
        if seen_black[nh][nw] == True:
            continue
        dfs_black(nh, nw)    

for h in range(H):
    field[h] = input().rstrip("\r\n")

sh, sw, gh, gw = 0, 0, H-1, W-1
ans = 0
is_next = True
if field[sh][sw] == "#":
    is_next = False
else:
    is_next = True

while seen[gh][gw] != True and seen_black[gh][gw] != True:
    if is_next:
        dfs(sh,sw)
        sh, sw = stop
        is_next = False
    else:
        ans += 1
        dfs_black(sh,sw)
        sh, sw = next_start
        is_next = True
print(ans)

### FIXED CODE ###

import sys
input = sys.stdin.readline
from collections import deque
def main():
    H, W = map(int, input().split())
    field = [input().rstrip("\r\n") for _ in range(H)]
    dv = 201
    counts = [[dv for _ in range(W)] for _ in range(H)]
    que = deque([(0, 0)])
    if field[0][0] == "#":
        counts[0][0] = 1
    else:
        counts[0][0] = 0
    while len(que) > 0:
        h, w = que.popleft()
        for dh, dw in [(1, 0), (0, 1)]:
            nh, nw = h + dh, w + dw
            if nh >= H or nw >= W:continue
            if counts[nh][nw] == dv:que.append((nh, nw))
            if field[h][w] != field[nh][nw]:
                counts[nh][nw] = min(counts[nh][nw], counts[h][w]+1)
            else:
                counts[nh][nw] = min(counts[nh][nw], counts[h][w])
    if field[-1][-1] == "#":counts[-1][-1] += 1
    print(counts[-1][-1]//2)
if __name__ == "__main__":
    main()
a,b,c,k=map(int,input().split())

if k%2 == 0:
  if abs(a-b)<=10**18:print(a-b)
elif ans(b-a)<=10**18:print(b-a)
else:print("Unfair")   

### FIXED CODE ###

a,b,c,k=map(int,input().split())

if k%2 == 0 and abs(a-b)<=10**18:print(a-b)
elif k%2 != 0 and abs(b-a)<=10**18:print(b-a)
else:print("Unfair")
N, A, B = map(int, input().split(' '))
 
row = ''
for i in range(int(N/(A+B)) +1):
    row+='b' * A
    row+= 'r' * B
print(list(row[:N]).count('b'))

### FIXED CODE ###

N, A, B = map(int, input().split(' '))
 
blue = 0
if N!=0 and A!=0:    
    blue = A *int(N/(A+B))
    if N%(A+B) <= A:
        blue += N%(A+B)
    else:
        blue += A 
print(blue)
#!/usr/bin/env python3
#ABC147 E

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

h,w = LI()
a = [LI() for _ in range(h)]
b = [LI() for _ in range(h)]

lst = [[0]*w for _ in range(h)]
m = 0
for i in range(h):
    for j in range(w):
        lst[i][j] = abs(a[i][j] - b[i][j])
        m = max(m,abs(a[i][j] - b[i][j]))

dp = [[[0]*((h+w-1)*m) for _ in range(w)] for _ in range(h)]
dp[0][0][lst[0][0]] = 1
for i in range(h):
    for j in range(w):
        for k in range(m*(h+w-1)):
            if dp[i][j][k]:
                if i+1 < h:
                    if k+lst[i+1][j] < m*(h+w-1):
                        dp[i+1][j][k+lst[i+1][j]] = 1
                    if abs(k-lst[i+1][j]) < m*(h+w-1):
                        dp[i+1][j][abs(k-lst[i+1][j])] = 1
                if j+1 < w:
                    if k+lst[i][j+1] < m*(h+w-1):
                        dp[i][j+1][k+lst[i][j+1]] = 1
                    if abs(k-lst[i][j+1]) < m*(h+w-1):
                        dp[i][j+1][abs(k-lst[i][j+1])] = 1

ans = 10**10
for i in range(m*(h+w-1)):
    if dp[-1][-1][i]:
        ans = min(ans,i)
print(ans)


### FIXED CODE ###

#!/usr/bin/env python3
#ABC147 E

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

h,w = LI()
a = [LI() for _ in range(h)]
b = [LI() for _ in range(h)]

dp = [[0 for _ in range(w)] for _ in range(h)]
lst = [[0]*w for _ in range(h)]
for i in range(h):
    for j in range(w):
        lst[i][j] = abs(a[i][j] - b[i][j])

dp[0][0] |= 1 << (6400+lst[0][0])
dp[0][0] |= 1 << (6400-lst[0][0])
for i in range(h):
    for j in range(w):
        t = dp[i][j]
        if i+1 < h:
            dp[i+1][j] |= t << lst[i+1][j]
            dp[i+1][j] |= t >> lst[i+1][j]
        if j+1 < w:
            dp[i][j+1] |= t << lst[i][j+1]
            dp[i][j+1] |= t >> lst[i][j+1]

x = dp[-1][-1]
for i in range(6401)[::-1]:
    if (x >> i) & 1:
        print(6400 - i)
        break
import math

n = int(raw_input())
print n * n * math.pi, 2 * n * math.pi

### FIXED CODE ###

import math
r = float(input())
print("%f %f" % (math.pi * r ** 2, 2 * math.pi * r))
import sys

a = []

for line in sys.stdin:
    a.append(map(float, raw_input().strip()))

for i in range(a):
    # adjusting d to a
    a = l[i][0]/l[i][3]
    l[i][3] = a * l[3]
    l[i][4] = a * l[4]
    l[5] = a * l[5]

    # calculating y
    y_1 = l[i][1] - l[i][4]
    y_2 = l[i][2] - l[i][5]

    y_answer = y_2/y_1

    # calculatiing x

    x_answer = (l[i][2] - l[i][1] * y_answer)/l[i][0]

    x_answer = round(x_answer)
    y_answer = round(y_answer)

    print "%3f %3f" % (x_answer, y_answer)

### FIXED CODE ###

while 1:
    def solver(a, b, c, d, e, f):
        answer = []

        if d == 0:
            y = f / e
            x = (c - b * y)/a

        else:
            m = a / d

            d = d * m
            e = e * m
            f = f * m

            y = (c - f)/(b - e)

            x = (c - b * y)/a

            if x == -0:
                x = 0
            if y == -0:
                y = 0

        answer.append(x)
        answer.append(y)
        return answer

    try:
        p_1, p_2, p_3, p_4, p_5, p_6 = map(float, raw_input().split())

        ans = []
        ans = solver(p_1, p_2, p_3, p_4, p_5, p_6)

        print "%.3f %.3f" % (ans[0], ans[1])

    except:
        break
from functools import lru_cache

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

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

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

safe_area.append(N - a_p)

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


### FIXED CODE ###

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

MOD = 1000000007

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

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

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

print(count_1)
h, n = map(int, input().split())
a = sorted(list(map(int, input().split())))
if a[-1] + a[-2] < h:
    print('No')
else:
    print('Yes')

### FIXED CODE ###

h, n = map(int, input().split())
a = sorted(list(map(int, input().split())))
if sum(a) < h:
    print('No')
else:
    print('Yes')
n,m=map(int,input().split())
A = [int(input()) for i in range(m)]
mod = 1000000007
memo={}
memo[1]=1

def fib(n):
  if n < 1:
    return 1
  if n in A:
  	memo[n]=0
  	return memo[n]
  if n not in memo:
    memo[n] = fib(n-1) + fib(n-2)
  return memo[n]

print(fib(n)%mod)

### FIXED CODE ###

n,m=map(int,input().split())
A = [int(input()) for i in range(m)]
ls =[-1]*(n+1)
ls[0]=ls[1]=1
mod = 10**9+7
for a in A:
	ls[a]= 0

for i in range(2,n+1):
	if ls[i]==-1:
		ls[i]= ls[i-1]+ls[i-2]
print(ls[-1]%mod)
a = input()
b = input()
print a*b
print 2*(a + b)

### FIXED CODE ###

a, b = map(int, raw_input().split())
print a*b, 2*a+2*b