import sys
from collections import defaultdict, deque, Counter
from itertools import combinations, permutations, accumulate, product
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from functools import lru_cache
from math import gcd, lcm, isqrt, inf
 
# 高速入力（sys.stdin.readline は input() の約 3 倍速い）
input = sys.stdin.readline
 
def main():
    # ============================
    # 入力パターン集
    # ============================
 
    # 整数 1 つ
    N = int(input())
 
    # 整数 2 つ
    # N, M = map(int, input().split())
 
    # 整数のリスト
    A = list(map(int, input().split()))
 
    # 文字列
    # S = input().strip()  # strip() で末尾の改行を除去
 
    # N 行の入力（グラフの辺など）
    # edges = [tuple(map(int, input().split())) for _ in range(M)]
 
    # グリッド入力
    # grid = [input().strip() for _ in range(H)]
 
    # ============================
    # 解法をここに記述
    # ============================
    ans = 0
 
    # ============================
    # 出力
    # ============================
    print(ans)
 
if __name__ == "__main__":
    main()

import sys
 
# 方法 1: sys.stdin.readline を input に差し替え
input = sys.stdin.readline
 
# 方法 2: 全入力を一括読み込み（最速）
def solve():
    data = sys.stdin.read().split()
    idx = 0
    def rd():
        nonlocal idx
        idx += 1
        return data[idx - 1]
 
    N = int(rd())
    A = [int(rd()) for _ in range(N)]
 
    # 解法...
    ans = sum(A)
    print(ans)
 
solve()
 
# 方法 3: 大量出力の高速化
def fast_output(results):
    """リストの各要素を改行区切りで出力"""
    sys.stdout.write('\n'.join(map(str, results)) + '\n')
 
# 方法 4: 再帰制限の拡張（DFS で深い再帰が必要な場合）
sys.setrecursionlimit(10**6)
 
# 方法 5: スレッドで再帰スタックサイズを確保
import threading
def main():
    sys.setrecursionlimit(10**6)
    # 再帰が深い DFS などの処理
    pass
 
threading.Thread(target=main, daemon=True).start()

#include <bits/stdc++.h>
using namespace std;
 
// 型エイリアス
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
 
// 定数
const int INF = 1e9;
const ll LINF = 1e18;
const int MOD = 1e9 + 7;
 
// マクロ
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) (v).begin(), (v).end()
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int N;
    cin >> N;
    vi A(N);
    rep(i, N) cin >> A[i];
 
    ll ans = 0;
    // 解法をここに記述
 
    cout << ans << endl;
    return 0;
}

def bit_bruteforce(n: int, items: list) -> list:
    """bit全探索で全部分集合を列挙する
 
    計算量: O(2^n * n)
    制約:   n <= 20 程度（2^20 = 約100万）
    """
    results = []
    for mask in range(1 << n):       # 0 から 2^n - 1 まで
        subset = []
        for i in range(n):
            if mask & (1 << i):      # i 番目のビットが立っているか
                subset.append(items[i])
        results.append(subset)
    return results
 
# 使用例
items = ['A', 'B', 'C']
subsets = bit_bruteforce(3, items)
# [[], ['A'], ['B'], ['A','B'], ['C'], ['A','C'], ['B','C'], ['A','B','C']]

def subset_sum(arr: list, target: int) -> bool:
    """部分和問題を bit 全探索で解く
 
    計算量: O(2^n * n)
    制約:   n <= 20
    """
    n = len(arr)
    for mask in range(1 << n):
        total = 0
        for i in range(n):
            if mask & (1 << i):
                total += arr[i]
        if total == target:
            return True
    return False
 
# テスト
print(subset_sum([3, 7, 1, 8, 4], 12))   # True  (3 + 1 + 8 = 12)
print(subset_sum([3, 7, 1, 8, 4], 2))    # False
print(subset_sum([3, 7, 1, 8, 4], 23))   # True  (3 + 7 + 1 + 8 + 4 = 23)
 
# より効率的な実装（popcount で判定不要な場合のスキップ）
def subset_sum_optimized(arr: list, target: int) -> list:
    """target と一致する部分集合を全て返す"""
    n = len(arr)
    results = []
    for mask in range(1 << n):
        total = sum(arr[i] for i in range(n) if mask & (1 << i))
        if total == target:
            subset = [arr[i] for i in range(n) if mask & (1 << i)]
            results.append(subset)
    return results
 
print(subset_sum_optimized([3, 7, 1, 8, 4], 12))
# [[3, 1, 8], [8, 4]]

def meet_in_the_middle(arr: list, target: int) -> bool:
    """半分全列挙で部分和問題を解く
 
    計算量: O(2^(n/2) * n)
    制約:   n <= 40
    """
    n = len(arr)
    half = n // 2
 
    # 前半の全部分和を集合に格納
    left_sums = set()
    for mask in range(1 << half):
        s = sum(arr[i] for i in range(half) if mask & (1 << i))
        left_sums.add(s)
 
    # 後半の各部分和について、target との差が前半に存在するか確認
    for mask in range(1 << (n - half)):
        s = sum(arr[half + i] for i in range(n - half) if mask & (1 << i))
        if target - s in left_sums:
            return True
 
    return False
 
# テスト: n = 30 の部分和問題も高速に解ける
import random
arr = [random.randint(1, 10**9) for _ in range(30)]
target = sum(arr[:5])  # 最初の 5 要素の和を target にする
print(meet_in_the_middle(arr, target))  # True

# ビット操作の基本テクニック（競プロで頻出）
 
# 1. i 番目のビットが立っているか
def is_set(mask, i):
    return bool(mask & (1 << i))
 
# 2. i 番目のビットを立てる
def set_bit(mask, i):
    return mask | (1 << i)
 
# 3. i 番目のビットを消す
def clear_bit(mask, i):
    return mask & ~(1 << i)
 
# 4. 最下位の立っているビットを取得
def lowest_bit(mask):
    return mask & (-mask)
 
# 5. 部分集合の列挙（mask の部分集合を降順で列挙）
def enumerate_subsets(mask):
    """mask のビットが立っている位置の部分集合を列挙"""
    sub = mask
    while sub > 0:
        yield sub
        sub = (sub - 1) & mask
    yield 0  # 空集合
 
# 6. popcount（立っているビットの数）
def popcount(mask):
    return bin(mask).count('1')
 
# 使用例: 3 つ選ぶ組合せを列挙
n = 5
for mask in range(1 << n):
    if popcount(mask) == 3:
        selected = [i for i in range(n) if mask & (1 << i)]
        print(selected)
# [0,1,2], [0,1,3], [0,1,4], [0,2,3], [0,2,4], ...

def coordinate_compress(arr: list) -> tuple:
    """座標圧縮を行う
 
    戻り値: (圧縮後の配列, 復元用の配列)
    計算量: O(n log n)
    """
    sorted_unique = sorted(set(arr))
    compress = {v: i for i, v in enumerate(sorted_unique)}
    compressed = [compress[v] for v in arr]
    return compressed, sorted_unique
 
# 基本的な使用例
data = [100, 5000, 300, 100, 10000]
compressed, mapping = coordinate_compress(data)
print(compressed)  # [0, 2, 1, 0, 3]
print(mapping)     # [100, 300, 5000, 10000]
 
# 復元
original = [mapping[c] for c in compressed]
print(original)    # [100, 5000, 300, 100, 10000]

def count_inversions(arr: list) -> int:
    """転倒数を座標圧縮 + BIT で計算する
 
    計算量: O(n log n)
    """
    # 座標圧縮
    compressed, _ = coordinate_compress(arr)
    n = len(compressed)
    max_val = max(compressed) + 1
 
    # BIT（Binary Indexed Tree）
    bit = [0] * (max_val + 2)
 
    def bit_update(i, delta=1):
        i += 1  # 1-indexed
        while i <= max_val + 1:
            bit[i] += delta
            i += i & (-i)
 
    def bit_query(i):
        """[0, i] の累積和"""
        i += 1
        s = 0
        while i > 0:
            s += bit[i]
            i -= i & (-i)
        return s
 
    # 右から走査し、自分より小さい値がいくつ既に登場しているかを数える
    inversions = 0
    for i in range(n - 1, -1, -1):
        if compressed[i] > 0:
            inversions += bit_query(compressed[i] - 1)
        bit_update(compressed[i])
 
    return inversions
 
# テスト
print(count_inversions([3, 1, 2]))      # 2  (3>1, 3>2)
print(count_inversions([1, 2, 3]))      # 0  (ソート済み)
print(count_inversions([3, 2, 1]))      # 3  (3>2, 3>1, 2>1)
print(count_inversions([5, 2, 6, 1]))   # 4  (5>2, 5>1, 2>1, 6>1)

def two_pointers_max_length(arr: list, threshold: int) -> int:
    """和が threshold 以下の最長連続部分列の長さを求める
 
    計算量: O(N)
    """
    n = len(arr)
    left = 0
    current_sum = 0
    max_len = 0
 
    for right in range(n):
        current_sum += arr[right]
 
        # 条件を満たさなくなるまで left を進める
        while current_sum > threshold:
            current_sum -= arr[left]
            left += 1
 
        # この時点で [left, right] は条件を満たす最長区間
        max_len = max(max_len, right - left + 1)
 
    return max_len
 
# テスト
print(two_pointers_max_length([2, 5, 1, 3, 7, 2, 4], 10))  # 3 ([2,5,1] or [5,1,3])
 
def two_pointers_count(arr: list, threshold: int) -> int:
    """和が threshold 以下の連続部分列の個数を求める
 
    計算量: O(N)
    ポイント: [l, r] が条件を満たすとき、[l, l], [l, l+1], ..., [l, r] の
              r - l + 1 個の区間も全て条件を満たす
    """
    n = len(arr)
    left = 0
    current_sum = 0
    count = 0
 
    for right in range(n):
        current_sum += arr[right]
        while current_sum > threshold:
            current_sum -= arr[left]
            left += 1
        count += right - left + 1  # right を右端とする条件を満たす区間の数
 
    return count
 
print(two_pointers_count([2, 5, 1, 3, 7, 2, 4], 10))  # 16

from collections import defaultdict
 
def at_most_k_distinct(arr: list, k: int) -> int:
    """異なる値が最大 k 種類の最長連続部分列の長さ
 
    計算量: O(N)
    """
    n = len(arr)
    left = 0
    freq = defaultdict(int)
    distinct = 0
    max_len = 0
 
    for right in range(n):
        if freq[arr[right]] == 0:
            distinct += 1
        freq[arr[right]] += 1
 
        while distinct > k:
            freq[arr[left]] -= 1
            if freq[arr[left]] == 0:
                distinct -= 1
            left += 1
 
        max_len = max(max_len, right - left + 1)
 
    return max_len
 
# テスト: 異なる値が最大 2 種類
print(at_most_k_distinct([1, 2, 1, 2, 3, 3, 4], 2))  # 4 ([1,2,1,2])
 
def exactly_k_distinct(arr: list, k: int) -> int:
    """異なる値がちょうど k 種類の連続部分列の個数
 
    テクニック: exactly(k) = at_most(k) - at_most(k-1)
    """
    def at_most(k):
        if k < 0:
            return 0
        left = 0
        freq = defaultdict(int)
        distinct = 0
        count = 0
        for right in range(len(arr)):
            if freq[arr[right]] == 0:
                distinct += 1
            freq[arr[right]] += 1
            while distinct > k:
                freq[arr[left]] -= 1
                if freq[arr[left]] == 0:
                    distinct -= 1
                left += 1
            count += right - left + 1
        return count
 
    return at_most(k) - at_most(k - 1)
 
print(exactly_k_distinct([1, 2, 1, 2, 3], 2))  # 7

MOD = 10**9 + 7
 
# 基本演算（加算・乗算は素直に MOD を取るだけ）
def mod_add(a, b, mod=MOD):
    return (a + b) % mod
 
def mod_sub(a, b, mod=MOD):
    return (a - b) % mod  # Python は負の余りを正しく処理する
 
def mod_mul(a, b, mod=MOD):
    return (a * b) % mod
 
# 繰り返し二乗法（累乗の高速計算）
def mod_pow(base, exp, mod=MOD):
    """base^exp mod mod を O(log exp) で計算する"""
    result = 1
    base %= mod
    while exp > 0:
        if exp & 1:              # exp が奇数
            result = result * base % mod
        exp >>= 1               # exp を半分にする
        base = base * base % mod
    return result
 
# Python 組み込みの pow(base, exp, mod) も同じ計算をする
# pow(2, 10, MOD) == mod_pow(2, 10, MOD) == 1024
 
# モジュラ逆元（フェルマーの小定理: a^(-1) ≡ a^(p-2) mod p, p は素数）
def mod_inv(a, mod=MOD):
    """a の mod 上の逆元を求める（mod が素数の場合）"""
    return mod_pow(a, mod - 2, mod)
 
# 除算: a / b mod p = a * b^(-1) mod p
def mod_div(a, b, mod=MOD):
    return a * mod_inv(b, mod) % mod

class Combinatorics:
    """組合せ計算を O(1) で行うためのクラス
 
    前計算: O(max_n)
    クエリ: O(1)
    """
    def __init__(self, max_n: int, mod: int = MOD):
        self.mod = mod
        self.fact = [1] * (max_n + 1)       # fact[i] = i! mod p
        self.inv_fact = [1] * (max_n + 1)   # inv_fact[i] = (i!)^(-1) mod p
 
        # 階乗の前計算
        for i in range(1, max_n + 1):
            self.fact[i] = self.fact[i - 1] * i % mod
 
        # 逆元の前計算（最大値から逆算）
        self.inv_fact[max_n] = pow(self.fact[max_n], mod - 2, mod)
        for i in range(max_n - 1, -1, -1):
            self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % mod
 
    def comb(self, n: int, r: int) -> int:
        """nCr mod p を O(1) で返す"""
        if r < 0 or r > n:
            return 0
        return self.fact[n] * self.inv_fact[r] % self.mod * self.inv_fact[n - r] % self.mod
 
    def perm(self, n: int, r: int) -> int:
        """nPr mod p を O(1) で返す"""
        if r < 0 or r > n:
            return 0
        return self.fact[n] * self.inv_fact[n - r] % self.mod
 
    def homo(self, n: int, r: int) -> int:
        """重複組合せ nHr = (n+r-1)Cr mod p"""
        return self.comb(n + r - 1, r)
 
    def catalan(self, n: int) -> int:
        """カタラン数 C_n = (2n)Cn / (n+1)"""
        return self.comb(2 * n, n) * pow(n + 1, self.mod - 2, self.mod) % self.mod
 
# 使用例
comb = Combinatorics(200000)
print(comb.comb(10, 3))         # 120
print(comb.comb(100000, 50000)) # 大きな値 mod 10^9+7
print(comb.perm(5, 3))          # 60
print(comb.catalan(5))          # 42

# パターン 1: 隣接リスト（重みなし）
# 入力:
# N M
# a1 b1
# a2 b2
# ...
 
def read_graph_unweighted():
    N, M = map(int, input().split())
    graph = [[] for _ in range(N)]
    for _ in range(M):
        a, b = map(int, input().split())
        a -= 1; b -= 1   # 0-indexed に変換
        graph[a].append(b)
        graph[b].append(a)  # 無向グラフの場合
    return N, graph
 
# パターン 2: 隣接リスト（重みあり）
# 入力:
# N M
# a1 b1 c1
# ...
 
def read_graph_weighted():
    N, M = map(int, input().split())
    graph = [[] for _ in range(N)]
    for _ in range(M):
        a, b, c = map(int, input().split())
        a -= 1; b -= 1
        graph[a].append((b, c))
        graph[b].append((a, c))
    return N, graph
 
# パターン 3: 木（親の指定）
# 入力: N 頂点の木で、頂点 i (2 <= i <= N) の親が p_i
# p_2 p_3 ... p_N
 
def read_tree_parent():
    N = int(input())
    parent = [-1] + [-1] + list(map(int, input().split()))
    # parent[i] = 頂点 i の親 (1-indexed)
    children = [[] for _ in range(N + 1)]
    for i in range(2, N + 1):
        children[parent[i]].append(i)
    return N, parent, children

import heapq
 
def dijkstra(graph: list, start: int) -> list:
    """ダイクストラ法（優先度付きキュー版）
 
    graph[u] = [(v, cost), ...]
    計算量: O((V + E) log V)
    """
    INF = float('inf')
    n = len(graph)
    dist = [INF] * n
    dist[start] = 0
    pq = [(0, start)]  # (距離, 頂点)
 
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u]:     # 既により短い経路が見つかっている
            continue
        for v, cost in graph[u]:
            nd = d + cost
            if nd < dist[v]:
                dist[v] = nd
                heapq.heappush(pq, (nd, v))
 
    return dist
 
# 経路復元が必要な場合
def dijkstra_with_path(graph: list, start: int, goal: int) -> tuple:
    """ダイクストラ法 + 経路復元"""
    INF = float('inf')
    n = len(graph)
    dist = [INF] * n
    prev_node = [-1] * n
    dist[start] = 0
    pq = [(0, start)]
 
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u]:
            continue
        if u == goal:
            break
        for v, cost in graph[u]:
            nd = d + cost
            if nd < dist[v]:
                dist[v] = nd
                prev_node[v] = u
                heapq.heappush(pq, (nd, v))
 
    # 経路復元
    if dist[goal] == INF:
        return INF, []
    path = []
    v = goal
    while v != -1:
        path.append(v)
        v = prev_node[v]
    path.reverse()
    return dist[goal], path

from collections import deque
 
def bfs(graph: list, start: int) -> list:
    """BFS（幅優先探索）- 重みなしグラフの最短距離
 
    計算量: O(V + E)
    """
    n = len(graph)
    dist = [-1] * n
    dist[start] = 0
    queue = deque([start])
 
    while queue:
        u = queue.popleft()
        for v in graph[u]:
            if dist[v] == -1:   # 未訪問
                dist[v] = dist[u] + 1
                queue.append(v)
 
    return dist
 
def dfs_iterative(graph: list, start: int) -> list:
    """DFS（深さ優先探索）- スタック版（再帰上限回避）
 
    計算量: O(V + E)
    """
    n = len(graph)
    visited = [False] * n
    order = []
    stack = [start]
 
    while stack:
        u = stack.pop()
        if visited[u]:
            continue
        visited[u] = True
        order.append(u)
        for v in graph[u]:
            if not visited[v]:
                stack.append(v)
 
    return order
 
# グリッド上の BFS（迷路の最短経路など）
def grid_bfs(grid: list, start: tuple, goal: tuple) -> int:
    """グリッド上の BFS
 
    grid[i][j] = '.' (通行可能) or '#' (壁)
    """
    H, W = len(grid), len(grid[0])
    dist = [[-1] * W for _ in range(H)]
    sy, sx = start
    gy, gx = goal
    dist[sy][sx] = 0
    queue = deque([(sy, sx)])
    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]  # 右左下上
 
    while queue:
        y, x = queue.popleft()
        if (y, x) == (gy, gx):
            return dist[y][x]
        for dy, dx in directions:
            ny, nx = y + dy, x + dx
            if 0 <= ny < H and 0 <= nx < W and grid[ny][nx] != '#' and dist[ny][nx] == -1:
                dist[ny][nx] = dist[y][x] + 1
                queue.append((ny, nx))
 
    return -1  # 到達不可能

class UnionFind:
    """Union-Find（素集合データ構造）
 
    経路圧縮 + union by rank で
    find, union ともにならし O(alpha(N)) ≈ O(1)
    """
    def __init__(self, n: int):
        self.parent = list(range(n))
        self.rank = [0] * n
        self.size = [1] * n
        self.num_groups = n
 
    def find(self, x: int) -> int:
        """x の根を返す（経路圧縮付き）"""
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
 
    def union(self, x: int, y: int) -> bool:
        """x と y を同じグループに統合する。既に同じなら False"""
        rx, ry = self.find(x), self.find(y)
        if rx == ry:
            return False
        if self.rank[rx] < self.rank[ry]:
            rx, ry = ry, rx
        self.parent[ry] = rx
        self.size[rx] += self.size[ry]
        if self.rank[rx] == self.rank[ry]:
            self.rank[rx] += 1
        self.num_groups -= 1
        return True
 
    def connected(self, x: int, y: int) -> bool:
        """x と y が同じグループか"""
        return self.find(x) == self.find(y)
 
    def group_size(self, x: int) -> int:
        """x が属するグループのサイズ"""
        return self.size[self.find(x)]
 
# 使用例: 連結成分の数を求める
def count_connected_components():
    N, M = map(int, input().split())
    uf = UnionFind(N)
    for _ in range(M):
        a, b = map(int, input().split())
        uf.union(a - 1, b - 1)
    print(uf.num_groups)

from itertools import accumulate
 
def prefix_sum_demo():
    """1 次元累積和の基本"""
    A = [3, 1, 4, 1, 5, 9, 2, 6]
 
    # 累積和の構築（先頭に 0 を置く）
    prefix = [0] + list(accumulate(A))
    # prefix = [0, 3, 4, 8, 9, 14, 23, 25, 31]
 
    # 区間 [l, r) の和 = prefix[r] - prefix[l]
    # 例: A[1] + A[2] + A[3] + A[4] = 1+4+1+5 = 11
    print(prefix[5] - prefix[1])  # 11
 
    # 全区間の和
    print(prefix[8] - prefix[0])  # 31
 
# 2 次元累積和
def prefix_sum_2d(grid: list) -> list:
    """2 次元累積和の構築
 
    H x W のグリッドに対して O(HW) で前計算
    矩形区間の和を O(1) で取得
    """
    H = len(grid)
    W = len(grid[0])
    # (H+1) x (W+1) の累積和テーブル
    ps = [[0] * (W + 1) for _ in range(H + 1)]
 
    for i in range(H):
        for j in range(W):
            ps[i + 1][j + 1] = (
                grid[i][j]
                + ps[i][j + 1]
                + ps[i + 1][j]
                - ps[i][j]
            )
    return ps
 
def query_2d(ps, r1, c1, r2, c2):
    """矩形 [r1, r2) x [c1, c2) の和を O(1) で取得"""
    return ps[r2][c2] - ps[r1][c2] - ps[r2][c1] + ps[r1][c1]
 
# テスト
grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
ps = prefix_sum_2d(grid)
print(query_2d(ps, 0, 0, 2, 2))  # 1+2+4+5 = 12
print(query_2d(ps, 1, 1, 3, 3))  # 5+6+8+9 = 28

def imos_1d(n: int, intervals: list) -> list:
    """1 次元 imos 法
 
    intervals: [(l, r), ...] 各区間 [l, r) に +1 を加算
    計算量: O(N + Q)  (N: 配列サイズ, Q: 区間の数)
    """
    diff = [0] * (n + 1)
    for l, r in intervals:
        diff[l] += 1
        diff[r] -= 1
 
    # 累積和で復元
    result = [0] * n
    result[0] = diff[0]
    for i in range(1, n):
        result[i] = result[i - 1] + diff[i]
 
    return result
 
# テスト
intervals = [(1, 4), (2, 6), (3, 5)]
print(imos_1d(7, intervals))  # [0, 1, 2, 3, 2, 1, 0]
 
def imos_2d(H: int, W: int, rectangles: list) -> list:
    """2 次元 imos 法
 
    rectangles: [(r1, c1, r2, c2), ...] 矩形 [r1,r2) x [c1,c2) に +1
    計算量: O(HW + Q)
    """
    diff = [[0] * (W + 1) for _ in range(H + 1)]
    for r1, c1, r2, c2 in rectangles:
        diff[r1][c1] += 1
        diff[r1][c2] -= 1
        diff[r2][c1] -= 1
        diff[r2][c2] += 1
 
    # 横方向の累積和
    for i in range(H):
        for j in range(1, W):
            diff[i][j] += diff[i][j - 1]
    # 縦方向の累積和
    for j in range(W):
        for i in range(1, H):
            diff[i][j] += diff[i - 1][j]
 
    return [row[:W] for row in diff[:H]]

from bisect import bisect_left, bisect_right
 
# パターン 1: ソート済み配列での検索
def binary_search_in_sorted(arr: list):
    """bisect モジュールの活用"""
    # arr = [1, 1, 2, 3, 4, 5, 6, 9]
 
    # x 以上の最小インデックス
    idx = bisect_left(arr, 3)   # 3
 
    # x より大きい最小インデックス
    idx = bisect_right(arr, 3)  # 4
 
    # x 以上の要素数
    count_ge = len(arr) - bisect_left(arr, 3)  # 5
 
    # x 以下の要素数
    count_le = bisect_right(arr, 3)             # 4
 
    # x が存在するか
    idx = bisect_left(arr, 3)
    exists = idx < len(arr) and arr[idx] == 3   # True
 
# パターン 2: 答えで二分探索（二分探索の一般化）
def binary_search_on_answer():
    """「条件を満たす最小（最大）の値を求めよ」型の問題"""
 
    def is_ok(mid: int) -> bool:
        """mid が条件を満たすか判定する関数"""
        # 問題に応じて実装
        return True
 
    # 条件を満たす最小値を求める
    lo, hi = 0, 10**18  # 探索範囲
    while lo < hi:
        mid = (lo + hi) // 2
        if is_ok(mid):
            hi = mid       # 条件を満たす → 左半分を探索
        else:
            lo = mid + 1   # 条件を満たさない → 右半分を探索
    # lo == hi が答え
 
    # 実数の二分探索（浮動小数点の場合）
    lo, hi = 0.0, 1e18
    for _ in range(100):   # 十分な回数ループ
        mid = (lo + hi) / 2
        if is_ok(int(mid)):
            hi = mid
        else:
            lo = mid
    # lo ≈ hi が答え
 
# パターン 3: 最小値の最大化（典型問題）
def minimize_maximum_distance(positions: list, k: int) -> int:
    """N 個の位置に K 個の中継点を追加し、
    隣接する点の最大距離を最小化する
 
    「答え d 以下にできるか？」を二分探索
    """
    positions.sort()
 
    def can_achieve(d):
        """最大距離を d 以下にするために必要な中継点数"""
        count = 0
        for i in range(len(positions) - 1):
            gap = positions[i + 1] - positions[i]
            count += (gap - 1) // d  # この区間に必要な中継点数
        return count <= k
 
    lo, hi = 1, positions[-1] - positions[0]
    while lo < hi:
        mid = (lo + hi) // 2
        if can_achieve(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

# デバッグ戦略 1: 愚直解とのストレステスト
import random
 
def brute_force(arr):
    """愚直な O(N^2) 解"""
    # ...正しいが遅い解法
    pass
 
def optimized(arr):
    """最適化した O(N log N) 解"""
    # ...高速だが正しいか不明な解法
    pass
 
def stress_test(n_tests=10000, max_n=10, max_val=100):
    """ランダムテストで愚直解と最適解を比較"""
    for _ in range(n_tests):
        n = random.randint(1, max_n)
        arr = [random.randint(1, max_val) for _ in range(n)]
        expected = brute_force(arr)
        actual = optimized(arr)
        if expected != actual:
            print(f"MISMATCH: arr={arr}")
            print(f"  expected={expected}, actual={actual}")
            return
    print("All tests passed!")
 
# デバッグ戦略 2: エッジケースチェックリスト
EDGE_CASES = """
  N = 0 (空入力)
  N = 1 (要素 1 つ)
  N = 2 (最小のペア)
  全要素が同じ値
  全要素が最大値 (10^9 等)
  ソート済み (昇順)
  ソート済み (降順)
  負の値が含まれる場合
  オーバーフローする可能性のある計算
  0-indexed と 1-indexed の変換ミス
"""

# 解答例
def solve_1_1():
    A = [2, 7, 3, 5, 11]
    target = 15
    n = len(A)
    for mask in range(1 << n):
        total = sum(A[i] for i in range(n) if mask & (1 << i))
        if total == target:
            subset = [A[i] for i in range(n) if mask & (1 << i)]
            print(f"Yes: {subset}")
            return
    print("No")
 
solve_1_1()  # Yes: [7, 3, 5] (合計 15)

# BAD: Python で 10^8 回のループ → 約 10 秒、TLE 確実
result = 0
for i in range(10**8):
    result += i
 
# GOOD: 対策 1 - PyPy で提出（3-10 倍高速）
# 提出言語を「PyPy3」に変更するだけ
 
# GOOD: 対策 2 - リスト内包表記（for 文の 2-3 倍速い）
# BAD
result = []
for i in range(n):
    result.append(i * i)
 
# GOOD
result = [i * i for i in range(n)]
 
# GOOD: 対策 3 - 組み込み関数を活用
# BAD
total = 0
for x in arr:
    total += x
 
# GOOD
total = sum(arr)
 
# GOOD: 対策 4 - ローカル変数化（グローバルアクセスは遅い）
def solve():
    # ローカル変数は LOAD_FAST 命令で高速アクセス
    n = len(arr)
    for i in range(n):
        pass

# BAD: N=1 のケースを忘れる
def solve_bad():
    N = int(input())
    A = list(map(int, input().split()))
    # N=1 のとき A[1] でインデックスエラー!
    print(A[0] + A[1])
 
# GOOD: エッジケースを先に処理
def solve_good():
    N = int(input())
    A = list(map(int, input().split()))
    if N == 1:
        print(A[0])
        return
    # 以降 N >= 2 を前提に処理
    print(A[0] + A[1])

# BAD: 浮動小数点の等値比較
if 0.1 + 0.2 == 0.3:  # False になる!
    print("equal")
 
# GOOD: 十分小さい epsilon で比較
EPS = 1e-9
if abs((0.1 + 0.2) - 0.3) < EPS:
    print("equal")
 
# BETTER: 可能なら整数に変換して計算
# 座標が小数 → 10^6 倍して整数化
# 確率 → 分数のまま計算（MOD 逆元で除算）

# BAD: Python のデフォルト再帰上限は 1000
def dfs(v, graph, visited):
    visited[v] = True
    for u in graph[v]:
        if not visited[u]:
            dfs(u, graph, visited)
# N = 10^5 の木で RecursionError
 
# GOOD: 再帰制限を拡張
import sys
sys.setrecursionlimit(10**6)
 
# BETTER: スタックベースの反復 DFS に書き換え
def dfs_iterative(start, graph):
    visited = set()
    stack = [start]
    while stack:
        v = stack.pop()
        if v in visited:
            continue
        visited.add(v)
        for u in graph[v]:
            if u not in visited:
                stack.append(u)