def oracles(n, q, ops, qs):
    a = []
    for b, x in ops:
        if b == 1:
            a.append(x)
        else:
            a = a * (x + 1)
    return [a[i-1] if i <= len(a) else 0 for i in qs]

n, q = map(int, input().split())
ops = [map(int, input().split()) for _ in range(n)]
qs = list(map(int, input().split()))

print(*oracles(n, q, ops, qs))

MAX_N = 100000

e = [0] * MAX_N

def canSplit(n, k, b):
    maxSum = 0
    s = 0
    br = 0

    for i in range(n):
        if s + e[i] > k or br == b - 1:
            br += 1
            s = e[i]
        else:
            s += e[i]
        
        maxSum = max(maxSum, s)
        
        if br >= b:
            return False
    
    return maxSum <= k

def minBranches(n, k):
    l, r = 1, n
    while l < r:
        mid = l + (r - l) // 2
        if canSplit(n, k, mid):
            r = mid
        else:
            l = mid + 1
    
    return l if canSplit(n, k, l) else -1

def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    
    n, m, k = map(int, data[:3])
    global e
    e = list(map(int, data[3:3+n]))
    
    print(minBranches(n, k))

if __name__ == "__main__":
    main()

#define ff first
#define ss second
struct minq{
    stack<pair<int,int>>s,t;
    void push(int x){
        int mn=(s.size()>0)?min(s.top().ss,x):x;
        s.push({x,mn});
    }   
    void pop(){
        if(t.empty()){
            while(!s.empty()){
                auto x=s.top();
                int mn=(t.size()>0)?min(x.ff,t.top().ss):x.ff;
                t.push({x.ff,mn});
                s.pop();
            }
        }
        t.pop();
    }
    int getmin(){
        int mn=INT_MAX;
        if(s.size())mn=min(mn,s.top().ss);
        if(t.size())mn=min(mn,t.top().ss);
        return mn;
    }
};

bool ok(string &s,vector<int>&a,int mid){
    minq v;
    for(int i=0;i<mid;i++){
        v.push(a[s[i]-'a']);
    }
    bool alpha=v.getmin()>=mid;
    for(int i=mid;i<s.size();i++){
        v.pop();
        v.push(a[s[i]-'a']);
        alpha|=(v.getmin()>=mid);
    }
    return alpha;
}
int getLongest(string &s,vector<int>&a){
    int st=0,en=s.size()-1;
    while(en-st>1){
        int mid=(en+st+1)/2;
        if(ok(s,a,mid)){
            st=mid;
        }
        else en=mid;
    }
    if(ok(s,a,en))return en;
    else return st;
}


vector<int>solve(vector<string>universe,vector<vector<int>>s){
    vector<int>ans;
    int n=universe.size();
    for(int i=0;i<n;i++){
        ans.push_back(getLongest(universe[i],s[i]));
    }
    return ans;
}

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
TreeNode* buildTree(vector<vector<int>>& levels) {
    if (levels.empty() || levels[0].empty() || levels[0][0] == -1) {
        return NULL;
    }
    
    TreeNode* root = new TreeNode(levels[0][0]);
    queue<TreeNode*> q;
    q.push(root);
    int level = 1;

    while (!q.empty() && level < levels.size()) {
        int size = q.size();
        for (int i = 0; i < size; ++i) {
            TreeNode* node = q.front();
            q.pop();
            if (node != NULL) {
                int left_val = levels[level][2 * i];
                int right_val = levels[level][2 * i + 1];

                if (left_val != -1) {
                    node->left = new TreeNode(left_val);
                    q.push(node->left);
                } else {
                    q.push(NULL);
                }

                if (right_val != -1) {
                    node->right = new TreeNode(right_val);
                    q.push(node->right);
                } else {
                    q.push(NULL);
                }
            }
        }
        level++;
    }

    return root;
}
TreeNode* findLCA(TreeNode* root, TreeNode* a, TreeNode* b) {
    if (!root || root == a || root == b) return root;

    TreeNode* left = findLCA(root->left, a, b);
    TreeNode* right = findLCA(root->right, a, b);

    if (left && right) return root;
    return left ? left : right;
}

int findDistance(TreeNode* root, TreeNode* target, int dist) {
    if (!root) return -1;
    if (root == target) return dist;

    int leftDist = findDistance(root->left, target, dist + 1);
    if (leftDist != -1) return leftDist;

    return findDistance(root->right, target, dist + 1);
}
void findLeafNodes(TreeNode* node, int depth, vector<pair<TreeNode*, int>>& leaves) {
    if (!node) return;

    if (!node->left && !node->right) {
        leaves.push_back({node, depth});
        return;
    }

    findLeafNodes(node->left, depth + 1, leaves);
    findLeafNodes(node->right, depth + 1, leaves);
}

int countPairs(TreeNode* root, vector<pair<TreeNode*, int>>& leaves, int k) {
    int count = 0;
    for (int i = 0; i < leaves.size(); ++i) {
        for (int j = i + 1; j < leaves.size(); ++j) {
            TreeNode* lca = findLCA(root, leaves[i].first, leaves[j].first);
            int dist = findDistance(lca, leaves[i].first, 0) + findDistance(lca, leaves[j].first, 0);
            if (dist <= k) count++;
        }
    }
    return count;
}

int main() {
    int k, n;
    cin >> k >> n;

    if (n == -1) {
        cout << "-1" << endl;
        return 0;
    }
    
    vector<vector<int>> levels(n + 1);
    for (int i = 0; i <= n; ++i) {
        int size = 1 << i; 
        levels[i].resize(size);
        for (int j = 0; j < size; ++j) {
            cin >> levels[i][j];
        }
    }
    
    TreeNode* root = buildTree(levels);
    vector<pair<TreeNode*, int>> leaves;
    findLeafNodes(root, 0, leaves);
    
    int result = countPairs(root, leaves, k);
    cout << (result == 0 ? "0" : to_string(result)) << endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
string numStr;
int dp[11][2][11][11][11];  
int digitDP(int pos, bool isTight, int count2, int count4, int count8) {
    if (pos == numStr.size()) {
        if (count2 > 0 && count2 == count4 && count4 == count8) {
            return 1;
        }
        return 0;
    }
        if (dp[pos][isTight][count2][count4][count8] != -1) {
        return dp[pos][isTight][count2][count4][count8];
    }
    
    int limit = isTight ? numStr[pos] - '0' : 9;  
    int result = 0;
    
    for (int digit = 0; digit <= limit; digit++) {
        int newCount2 = count2 + (digit == 2);
        int newCount4 = count4 + (digit == 4);
        int newCount8 = count8 + (digit == 8);
         result = (result + digitDP(pos + 1, isTight && (digit == limit), newCount2, newCount4, newCount8)) % MOD;
    }
        return dp[pos][isTight][count2][count4][count8] = result;
}

int count248Numbers(long long N) {
    numStr = to_string(N);  
    memset(dp, -1, sizeof(dp));  
    return digitDP(0, true, 0, 0, 0); 
}

int main() {
    long long N;
    cin >> N;
    cout << count248Numbers(N) << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int findLongestAP(vector<int>& arr) {
    int n = arr.size();
    if (n == 0) return 1;  
    if (n < 3) return 0;   
    vector<unordered_map<int, int>> dp(n);
    
    int maxLength = 2;  
    for (int j = 1; j < n; j++) {
        for (int i = 0; i < j; i++) {
            int diff = arr[j] - arr[i];  
            if (dp[i].find(diff) != dp[i].end()) {
                dp[j][diff] = dp[i][diff] + 1;
            } else {
                dp[j][diff] = 2;
            }
            
        maxLength = max(maxLength, dp[j][diff]);
        }
    }
    
    return maxLength >= 3 ? maxLength : 0;  
}

int main() {
    int I;
    cin >> I;
    
    vector<int> arr(I);
    for (int i = 0; i < I; i++) {
        cin >> arr[i];
    }
        cout << findLongestAP(arr) << endl;
    
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
    vector<int> parent, rank, has_tank;
    
    UnionFind(int n) {
        parent.resize(n);
        rank.resize(n, 0);
        has_tank.resize(n, 0);
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
        int find(int x) {
        if (x != parent[x]) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
        void union_sets(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        
        if (rootX != rootY) {
            if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
                has_tank[rootX] |= has_tank[rootY];  
            } else if (rank[rootX] < rank[rootY]) {
                parent[rootX] = rootY;
                has_tank[rootY] |= has_tank[rootX]; 
            } else {
                parent[rootY] = rootX;
                rank[rootX]++;
                has_tank[rootX] |= has_tank[rootY]; 
            }
        }
    }
        void set_tank(int x) {
        int rootX = find(x);
        has_tank[rootX] = 1;
    }
        bool is_tank(int x) {
        return has_tank[find(x)];
    }
};

int main() {
    int m, n;
    cin >> m >> n; 

    vector<tuple<int, int, int>> edges;  
    for (int i = 0; i < m - 1; i++) {
        int u, v, time;
        cin >> u >> v >> time;
        edges.push_back({time, u, v});
    }

    vector<int> tank_states(n);
    for (int i = 0; i < n; i++) {
        cin >> tank_states[i];
    }
    sort(edges.rbegin(), edges.rend());
    UnionFind uf(m);
    for (int tank : tank_states) {
        uf.set_tank(tank);
    }

    int total_time = 0;
    for (auto& [time, u, v] : edges) {
        if (uf.is_tank(u) && uf.is_tank(v)) {
            total_time += time;
        } else {
            uf.union_sets(u, v);
        }
    }
    cout << total_time << endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool ss(int k, const vector<int>& trees, const vector<int>& sprinklers) {
    int m = sprinklers.size();
    int n = trees.size();
    int i = 0, j = 0;
        while (i < n) {
        if (j < m && trees[i] >= sprinklers[j] - k && trees[i] <= sprinklers[j] + k) {
            i++; 
        } else if (j < m && trees[i] > sprinklers[j] + k) {
            j++; 
        } else {
            return false;  
        }
    }
    
    return true;  
}

int main() {
    int N, M;
    cin >> N;
    vector<int> trees(N);
    for (int i = 0; i < N; i++) {
        cin >> trees[i];
    }
    cin >> M;
    vector<int> sprinklers(M);
    for (int i = 0; i < M; i++) {
        cin >> sprinklers[i];
    }
    sort(trees.begin(), trees.end());
    sort(sprinklers.begin(), sprinklers.end());
        int left = 0;
    int right = max(abs(trees.back() - sprinklers.front()), abs(sprinklers.back() - trees.front()));
    int result = right;
    
    while (left <= right) {
        int mid = (left + right) / 2;
                if (ss(mid, trees, sprinklers)) {
            result = mid; 
            right = mid - 1;
        } else {
            left = mid + 1; 
        }
    }
        cout << result << endl;
    
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int solve(vector<int>& arr, int k) {
    sort(arr.begin(), arr.end());
    int i = 0, j = arr.size() - 1;
    int moves = 0;
    while (i <= j) {
        if (arr[i] + arr[j] <= k) {
            i++;
            j--;
        } else {
            j--;
        }
        moves++; 
    }
    
    return moves;
}