1D, K = map(int, input().split())
 2L = [(1, 0), (0, 1)]
 3
 4for i in range(2, D):
 5    L.append((L[i-2][0]+L[i-1][0], L[i-2][1]+L[i-1][1]))
 6
 7A = 1
 8B = 2
 9
10while True:
11    if A*L[D-1][0] + B*L[D-1][1] == K:
12        break
13
14    if A+1 == B:
15        B += 1
16        A = 1
17    else:
18        A += 1
19
20print (A,'\n',B, sep='')

 1import sys
 2sys.setrecursionlimit(10**6)
 3input = sys.stdin.readline
 4N, R, Q = map(int, input().split())
 5G = [[] for _ in range(N)]
 6cnt = [1]*N
 7visited = [False]*N
 8
 9for _ in range(N-1):
10    a, b = map(int, input().split())
11    G[a-1].append(b-1)
12    G[b-1].append(a-1)
13
14def dfs(node):
15    visited[node] = True
16
17    for i in G[node]:
18        if not visited[i]:
19            cnt[node] += dfs(i)
20    return cnt[node]
21
22dfs(R-1)
23
24for _ in range(Q):
25    print (cnt[int(input())-1])

 1import sys
 2sys.setrecursionlimit(10**6)
 3M = int(input())
 4G = [[] for _ in range(M)]
 5
 6for _ in range(M-1):
 7    a, b, c = map(int, input().split())
 8    G[a-1].append((b-1, c))
 9    G[b-1].append((a-1, c))
10
11n1 = 0
12tmp = 0
13
14def dfs(node, length):
15    global n1, tmp
16    visit[node] = True
17    if length > tmp:
18        tmp = length
19        n1 = node
20    for child, v in G[node]:
21        if not visit[child]:
22            dfs(child, length+v)
23
24visit = [False]*M
25dfs(0, 0)
26tmp = 0
27visit = [False]*M
28dfs(n1, 0)
29print (tmp)

 1import sys
 2sys.setrecursionlimit(10**6)
 3input = sys.stdin.readline
 4
 5V = int(input())
 6G = [[] for _ in range(V)]
 7for _ in range(V):
 8    token = list(map(int, input().split()))[:-1]
 9    for i in range(1, len(token), 2):
10        G[token[0]-1].append((token[i]-1, token[i+1]))
11
12def dfs(node, dist):
13    global max_node, max_dist
14    visited[node] = True
15    if dist > max_dist:
16        max_node = node
17        max_dist = dist
18    for n_node, n_dist in G[node]:
19        if not visited[n_node]:
20            dfs(n_node, dist+n_dist)
21
22max_node = 0
23
24max_dist = 0
25visited = [False]*V
26dfs(0, 0)
27max_dist = 0
28visited = [False]*V
29dfs(max_node, 0)
30
31print (max_dist)

 1N, M, R = map(int, input().split())
 2
 3item = list(map(int, input().split()))
 4G = [[] for _ in range(N)]
 5for _ in range(R):
 6    a, b, c = map(int, input().split())
 7    G[a-1].append((b-1, c))
 8    G[b-1].append((a-1, c))
 9
10def dfs(node, dist):
11    global result
12    if dist > M:
13        return
14    if not visit[node]:
15        result += item[node]
16    visit[node] = True
17
18    for n_node, n_dist in G[node]:
19        dfs(n_node, dist+n_dist)
20
21max_result = 0
22
23for i in range(N):
24    result = 0
25    visit = [False]*N
26    dfs(i, 0)
27    max_result = max(max_result, result)
28
29print (max_result)

 1import sys
 2
 3sys.setrecursionlimit(10**6)
 4class Node:
 5    def __init__(self, value):
 6        self.value = value
 7        self.left = None
 8        self.right = None
 9
10class BinaryTree:
11    def __init__(self, root):
12        self.root = root
13
14    def insert(self, value):
15        cur_node = self.root
16        while True:
17            if value < cur_node.value:
18                if cur_node.left != None:
19                    cur_node =  cur_node.left
20                else:
21                    cur_node.left = Node(value)
22                    break
23            else:
24                if cur_node.right != None:
25                    cur_node = cur_node.right
26                else:
27                    cur_node.right = Node(value)
28                    break
29
30    def traverse(self, node):
31        if node.left != None:
32            self.traverse(node.left)
33        if node.right != None:
34            self.traverse(node.right)
35        print (node.value)
36try:
37    tree = BinaryTree(Node(int(input())))
38except:
39    exit()
40
41while True:
42    try:
43        tree.insert(int(input()))
44    except:
45        break
46
47tree.traverse(tree.root)

 1import sys
 2sys.setrecursionlimit(10**6)
 3
 4L = []
 5while True:
 6    try:
 7        L.append(int(input()))
 8    except:
 9        break
10
11def traverse(root, end):
12    if root > end:
13        return
14    mid = end + 1
15
16    for i in range(root+1, end+1):
17        if L[root] < L[i]:
18            mid = i
19            break
20
21    traverse(root+1, mid-1)
22    traverse(mid, end)
23    print (L[root])
24
25traverse(0, len(L)-1)

 1N, M = map(int, input().split())
 2T = list(map(int, input().split()))
 3T = set(T[1:])
 4
 5member = [set() for _ in range(N)]
 6party = []
 7visit = [False]*M
 8
 9def explore(n):
10    for i in member[n]:
11        if not visit[i]:
12            visit[i] = True
13            for j in party[i]:
14                explore(j-1)
15
16for i in range(M):
17    lst = list(map(int, input().split()))
18    lst = lst[1:]
19    for j in lst:
20        member[j-1].add(i)
21    party.append(set(lst))
22
23for i in T:
24    explore(i-1)
25
26cnt = 0
27for i in visit:
28    if not i:
29        cnt += 1
30
31print (cnt)

 1import math
 2
 3N = int(input())
 4K = int(math.log2(N//3))
 5arr = [[' '] * (2*N-1) for _ in range(N)]
 6
 7
 8def solve(depth, bx, by):
 9    if depth == 0:
10        for i in range(3):
11            for j in range(i*2+1):
12                arr[by+i][bx+(2-i)+j] = '*'
13        arr[by+1][bx+2] = ' '
14    else:
15        px = 2**(depth)*3
16        py = 2**(depth-1)*3
17        solve(depth-1, bx+px//2, by)
18        solve(depth-1, bx, by+py)
19        solve(depth-1, bx+px, by+py)
20solve(K, 0, 0)
21for i in arr:
22    print (''.join(i))

 1from collections import deque
 2
 3position_a, position_b = map(int, input().split())
 4
 5q = deque()
 6visited = [False]*100001
 7result = 0
 8cnt = 1
 9
10q.append((0, position_a))
11while q:
12    time, cur = q.popleft();
13    visited[cur] = True
14
15    if cur == position_b:
16        result = time
17        for i in q:
18            if i == (time, cur):
19                cnt += 1
20        break
21    if cur-1 >= 0 and not visited[cur-1]:
22        q.append((time+1, cur-1))
23    if cur+1 <= 100000 and not visited[cur+1]:
24        q.append((time+1, cur+1))
25    if cur*2 <= 100000 and not visited[cur*2]:
26        q.append((time+1, cur*2))
27
28print (result)
29print (cnt)

 1R, C, T = map(int, input().split())
 2L = [list(map(int, input().split())) for _ in range(R)]
 3
 4dx = [0, 1, 0, -1]
 5dy = [-1, 0, 1, 0]
 6dx2 = [0, 1, 0, -1]
 7dy2 = [1, 0, -1, 0]
 8
 9pur_a = (0, 0)
10pur_b = (0, 0)
11
12for i in range(R):
13    if L[i][0] == -1:
14        pur_a = (i, 0)
15        pur_b = (i+1, 0)
16        break
17
18def diffuse(L):
19    L_ = [[0]*C for _ in range(R)]
20
21    for i in range(R):
22        for j in range(C):
23            if L[i][j] > 0:
24                cnt = 0
25                for k in range(4):
26                    px = j+dx[k]
27                    py = i+dy[k]
28
29                    if 0 <= px < C and 0 <= py < R and L[py][px] != -1:
30                        L_[py][px] += L[i][j] // 5
31                        cnt += 1
32                L_[i][j] += L[i][j] - ((L[i][j] // 5)*cnt)
33
34    return L_
35
36def air_purify(L):
37    x = pur_a[1]
38    y = pur_a[0]
39    lastX = 0
40    lastY = 0
41    i = 0
42    while i < 4:
43        lastX = x
44        lastY = y
45        x += dx[i]
46        y += dy[i]
47
48        if not (0 <= x < C and 0 <= y < R) or (x, y) == (C-1, pur_a[0]+1):
49            x -= dx[i]
50            y -= dy[i]
51            lastX = x
52            lastY = y
53            i += 1
54            continue
55        if (x, y) == (pur_a[1], pur_a[0]):
56            L[pur_a[0]][pur_a[1]+1] = 0
57            L[pur_a[0]][pur_a[1]] = -1
58            break
59        L[lastY][lastX] = L[y][x]
60
61    x = pur_b[1]
62    y = pur_b[0]
63    i = 0
64    while i < 4:
65        lastX = x
66        lastY = y
67        x += dx2[i]
68        y += dy2[i]
69
70        if not (0 <= x < C and 0 <= y < R) or (x, y) == (C-1, pur_b[0]-1):
71            x -= dx2[i]
72            y -= dy2[i]
73            lastX = x
74            lastY = y
75            i += 1
76            continue
77        if (x, y) == (pur_b[1], pur_b[0]):
78            L[pur_b[0]][pur_b[1]+1] = 0
79            L[pur_b[0]][pur_b[1]] = -1
80            break
81        L[lastY][lastX] = L[y][x]
82
83for i in range(T):
84    L = diffuse(L)
85    air_purify(L)
86
87result = 0
88for i in L:
89    for j in i:
90        if j != -1:
91            result += j
92print (result)