Problem:


Score : 700 points

Problem Statement

We have a rooted binary tree with N vertices, where the vertices are numbered 1 to N.
Vertex 1 is the root, and the parent of Vertex i (i \geq 2) is Vertex \left[ \frac{i}{2} \right].

Each vertex has one item in it. The item in Vertex i has a value of V_i and a weight of W_i.
Now, process the following query Q times:

Given are a vertex v of the tree and a positive integer L.
  Let us choose some (possibly none) of the items in v and the ancestors of v so that their total weight is at most L.
  Find the maximum possible total value of the chosen items.

Here, Vertex u is said to be an ancestor of Vertex v when u is an indirect parent of v, that is, there exists a sequence of vertices w_1,w_2,\ldots,w_k (k\geq 2) where w_1=v, w_k=u, and w_{i+1} is the parent of w_i for each i.

Constraints

All values in input are integers.

1 \leq N < 2^{18}

1 \leq Q \leq 10^5

1 \leq V_i \leq 10^5

1 \leq W_i \leq 10^5

For the values v and L given in each query, 1 \leq v \leq N and 1 \leq L \leq 10^5.

Input

Let v_i and L_i be the values v and L given in the i-th query.
Then, Input is given from Standard Input in the following format:

N
V_1 W_1
:
V_N W_N
Q
v_1 L_1
:
v_Q L_Q

Output

For each integer i from 1 through Q,
the i-th line should contain the response to the i-th query.

Sample Input 1

3
1 2
2 3
3 4
3
1 1
2 5
3 5

Sample Output 1

0
3
3

In the first query, we are given only one choice: the item with (V, W)=(1,2). Since L = 1, we cannot actually choose it, so our response should be 0.

In the second query, we are given two choices: the items with (V, W)=(1,2) and (V, W)=(2,3). Since L = 5, we can choose both of them, so our response should be 3.

Sample Input 2

15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227

Sample Output 2

256
255
250
247
255
259
223
253



Sample input:
3
1 2
2 3
3 4
3
1 1
2 5
3 5


Sample output:
0
3
3

Submission status: Runtime Error

Solution code:
def examA():
    N = DI()/dec(7)
    ans = N
    print(N)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    N = I()
    n = N.bit_length()
    V = [0]*N; W = [0]*N
    for i in range(N):
        V[i], W[i] = LI()
    q = I()
    Q = [LI()for _ in range(q)]
    ans = [0]*q
    if N<1024:
        S = [[]for _ in range(N)]
        for i in range(N):
            key = i + 1
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            #print(D)
            now = 0
            for j in range(len(D)):
                if now < D[j][1]:
                    now = D[j][1]
                else:
                    D[j] = [D[j][0],now]
            S[i] = D

        for i,[v,l] in enumerate(Q):
            D = S[v-1]
            for j in range(len(D))[::-1]:
                if D[j][0]<=l:
                    ans[i] = D[j][1]
                    break
        for v in ans:
            print(v)
        return


    half = 1<<9
    S = [[0]*(100001) for _ in range(half)]
    for i in range(half//2,half):
        key = i + 1
        cur = []
        while (key > 0):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value
        D = sorted(dp.items())
        now = 0
        for j in range(len(D)):
            if now < D[j][1]:
                now = D[j][1]
            else:
                D[j] = [D[j][0],now]
        now = 0
        j = 0
        for s in range(100001):
            if j<len(D) and s==D[j][0]:
                now = D[j][1]
                j += 1
            S[i][s] = now

    for i,[v,l] in enumerate(Q):
        v -= 1
        key = v + 1
        if key<=512:
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            if D[j][0] <= l:
                if ans[i]<D[j][1]:
                    ans[i] = D[j][1]
            continue
        cur = []
        while (key > 512):
            cur.append(key-1)
            key //= 2
        k = len(cur)
        D2 = S[key - 1]
        latter_W = [0] * (1 << k)
        latter_V = [0] * (1 << k)
        ans[i] = deepcopy(D2[l])
        for loop in range(1, 1<<k):
            a = loop & (-loop)
            b = loop.bit_length() - 1

            now_w = latter_W[loop-a] + W[cur[b]]

            now_v = latter_V[i-a] + V[cur[b]]

            #latter_W[i] = now_w
            #latter_V[i] = now_v

            #if now_w<=l:
            #    ans[i] = max(ans[i], D2[l - now_w] + now_v)


    for v in ans:
        print(v)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examE()

"""

        for weight,value in dp:
            if weight>l:
                continue
            now = l-weight
            if ans[i]<D2[now]+value:
                ans[i] = D2[now]+value
"""

Submission status: Runtime Error

Solution code:
def examA():
    N = DI()/dec(7)
    ans = N
    print(N)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    N = I()
    n = N.bit_length()
    V = [0]*N; W = [0]*N
    for i in range(N):
        V[i], W[i] = LI()
    q = I()
    Q = [LI()for _ in range(q)]
    ans = [0]*q
    if N<1024:
        S = [[]for _ in range(N)]
        for i in range(N):
            key = i + 1
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            #print(D)
            now = 0
            for j in range(len(D)):
                if now < D[j][1]:
                    now = D[j][1]
                else:
                    D[j] = [D[j][0],now]
            S[i] = D

        for i,[v,l] in enumerate(Q):
            D = S[v-1]
            for j in range(len(D))[::-1]:
                if D[j][0]<=l:
                    ans[i] = D[j][1]
                    break
        for v in ans:
            print(v)
        return


    half = 1<<9
    S = [[0]*(100001) for _ in range(half)]
    for i in range(half//2,half):
        key = i + 1
        cur = []
        while (key > 0):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value
        D = sorted(dp.items())
        now = 0
        for j in range(len(D)):
            if now < D[j][1]:
                now = D[j][1]
            else:
                D[j] = [D[j][0],now]
        now = 0
        j = 0
        for s in range(100001):
            if j<len(D) and s==D[j][0]:
                now = D[j][1]
                j += 1
            S[i][s] = now

    for i,[v,l] in enumerate(Q):
        v -= 1
        key = v + 1
        if key<=512:
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            if D[j][0] <= l:
                if ans[i]<D[j][1]:
                    ans[i] = D[j][1]
            continue
        cur = []
        while (key > 512):
            cur.append(key-1)
            key //= 2
        k = len(cur)
        D2 = S[key - 1]
        latter_W = [0] * (1 << k)
        latter_V = [0] * (1 << k)
        ans[i] = D2[l]
        for loop in range(1, 1<<k):
            a = loop & (-loop)
            b = loop.bit_length() - 1

            now_w = latter_W[loop-a] + W[cur[b]]

            now_v = latter_V[i-a] + V[cur[b]]

            latter_W[i] = now_w
            latter_V[i] = now_v

            if now_w<=l:
                ans[i] = max(ans[i], D2[l - now_w] + now_v)


    for v in ans:
        print(v)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examE()

"""

        for weight,value in dp:
            if weight>l:
                continue
            now = l-weight
            if ans[i]<D2[now]+value:
                ans[i] = D2[now]+value
"""

Submission status: Runtime Error

Solution code:
def examA():
    N = DI()/dec(7)
    ans = N
    print(N)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    N = I()
    n = N.bit_length()
    V = [0]*N; W = [0]*N
    for i in range(N):
        V[i], W[i] = LI()
    q = I()
    Q = [LI()for _ in range(q)]
    ans = [0]*q
    if N<1024:
        S = [[]for _ in range(N)]
        for i in range(N):
            key = i + 1
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            #print(D)
            now = 0
            for j in range(len(D)):
                if now < D[j][1]:
                    now = D[j][1]
                else:
                    D[j] = [D[j][0],now]
            S[i] = D

        for i,[v,l] in enumerate(Q):
            D = S[v-1]
            for j in range(len(D))[::-1]:
                if D[j][0]<=l:
                    ans[i] = D[j][1]
                    break
        for v in ans:
            print(v)
        return


    half = 1<<9
    S = [[0]*(100001) for _ in range(half)]
    for i in range(half//2,half):
        key = i + 1
        cur = []
        while (key > 0):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value
        D = sorted(dp.items())
        now = 0
        for j in range(len(D)):
            if now < D[j][1]:
                now = D[j][1]
            else:
                D[j] = [D[j][0],now]
        now = 0
        j = 0
        for s in range(100001):
            if j<len(D) and s==D[j][0]:
                now = D[j][1]
                j += 1
            S[i][s] = now

    for i,[v,l] in enumerate(Q):
        v -= 1
        key = v + 1
        if key<=512:
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            if D[j][0] <= l:
                if ans[i]<D[j][1]:
                    ans[i] = D[j][1]
            continue
        cur = []
        while (key > 512):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value

        D2 = S[key-1]
        for weight,value in dp:
            if weight>l:
                continue
            now = l-weight
            if ans[i]<D2[now]+value:
                ans[i] = D2[now]+value

    for v in ans:
        print(v)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examE()

"""

"""

Submission status: Runtime Error

Solution code:
def examA():
    N = DI()/dec(7)
    ans = N
    print(N)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    N = I()
    n = N.bit_length()
    V = [0]*N; W = [0]*N
    for i in range(N):
        V[i], W[i] = LI()
    q = I()
    Q = [LI()for _ in range(q)]
    ans = [0]*q
    if N<1024:
        S = [[]for _ in range(N)]
        for i in range(N):
            key = i + 1
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            #print(D)
            now = 0
            for j in range(len(D)):
                if now < D[j][1]:
                    now = D[j][1]
                else:
                    D[j] = [D[j][0],now]
            S[i] = D

        for i,[v,l] in enumerate(Q):
            D = S[v-1]
            for j in range(len(D))[::-1]:
                if D[j][0]<=l:
                    ans[i] = D[j][1]
                    break
        for v in ans:
            print(v)
        return


    half = 1<<9
    S = [[] for _ in range(half)]
    for i in range(half//2,half):
        key = i + 1
        cur = []
        while (key > 0):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value
        D = sorted(dp.items())
        now = 0
        for j in range(len(D)):
            if now < D[j][1]:
                now = D[j][1]
            else:
                D[j][1] = now
        S[i] = D

    for v in ans:
        print(v)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examE()

"""
    for i,[v,l] in enumerate(Q):
        v -= 1
        key = v + 1
        if key<=512:
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            if D[j][0] <= l:
                if ans[i]<D[j][1]:
                    ans[i] = D[j][1]
            continue
        cur = []
        while (key > 512):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value
        D = sorted(dp.items())

        D2 = S[key-1]
        now = len(D2)-1
        for j in range(len(D)):
            while(now>=0 and D2[now][0]+D[j][0]>l):
                now -= 1
            if now==-1:
                break
            if ans[i]<D2[now][1]+D[j][1]:
                ans[i] = D2[now][1]+D[j][1]
"""

Submission status: Runtime Error

Solution code:
def examA():
    N = DI()/dec(7)
    ans = N
    print(N)
    return

def examB():
    ans = 0
    print(ans)
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    N = I()
    n = N.bit_length()
    V = [0]*N; W = [0]*N
    for i in range(N):
        V[i], W[i] = LI()
    q = I()
    Q = [LI()for _ in range(q)]
    ans = [0]*q
    if N<1024:
        S = [[]for _ in range(N)]
        for i in range(N):
            key = i + 1
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            #print(D)
            now = 0
            for j in range(len(D)):
                if now < D[j][1]:
                    now = D[j][1]
                else:
                    D[j] = [D[j][0],now]
            S[i] = D

        for i,[v,l] in enumerate(Q):
            D = S[v-1]
            for j in range(len(D))[::-1]:
                if D[j][0]<=l:
                    ans[i] = D[j][1]
                    break
        for v in ans:
            print(v)
        return

    half = 1<<9
    S = [[] for _ in range(half)]
    for i in range(half//2,half):
        key = i + 1
        cur = []
        while (key > 0):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value
        D = sorted(dp.items())
        now = 0
        for j in range(len(D)):
            if now < D[j][1]:
                now = D[j][1]
            else:
                D[j][1] = now
        S[i] = D

    for i,[v,l] in enumerate(Q):
        v -= 1
        key = v + 1
        if key<=512:
            cur = []
            while (key > 0):
                cur.append(key-1)
                key //= 2
            dp = {0: 0}
            for loop in range(1 << (len(cur))):
                value, weight = 0, 0
                for j in range(len(cur)):
                    if loop & (1 << j):
                        value += V[cur[j]]
                        weight += W[cur[j]]
                if weight in dp:
                    if dp[weight] < value:
                        dp[weight] = value
                else:
                    dp[weight] = value
            D = sorted(dp.items())
            if D[j][0] <= l:
                if ans[i]<D[j][1]:
                    ans[i] = D[j][1]
            continue


    for v in ans:
        print(v)
    return

def examF():
    ans = 0
    print(ans)
    return

from decimal import getcontext,Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(input())
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(input())
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = dec("0.000000000001")
alphabet = [chr(ord('a') + i) for i in range(26)]
alphabet_convert = {chr(ord('a') + i): i for i in range(26)}

getcontext().prec = 28

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examE()

"""
        cur = []
        while (key > 512):
            cur.append(key-1)
            key //= 2
        dp = {0: 0}
        for loop in range(1 << (len(cur))):
            value, weight = 0, 0
            for j in range(len(cur)):
                if loop & (1 << j):
                    value += V[cur[j]]
                    weight += W[cur[j]]
            if weight in dp:
                if dp[weight] < value:
                    dp[weight] = value
            else:
                dp[weight] = value
        D = sorted(dp.items())

        D2 = S[key-1]
        now = len(D2)-1
        for j in range(len(D)):
            while(now>=0 and D2[now][0]+D[j][0]>l):
                now -= 1
            if now==-1:
                break
            if ans[i]<D2[now][1]+D[j][1]:
                ans[i] = D2[now][1]+D[j][1]
"""