【CodeForces 380A】Sereja and Prefixes（二分）

A. Sereja and Prefixes

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Sereja loves number sequences very much. That's why he decided to make himself a new one following a certain algorithm.

Sereja takes a blank piece of paper. Then he starts writing out the sequence in m stages. Each time he either adds a new number to the end of the sequence or takes l first elements of the current sequence and adds them c times to the end. More formally, if we represent the current sequence as a₁, a₂, ..., a_n, then after we apply the described operation, the sequence transforms into a₁, a₂, ..., a_n[, a₁, a₂, ..., a_l] (the block in the square brackets must be repeated c times).

A day has passed and Sereja has completed the sequence. He wonders what are the values of some of its elements. Help Sereja.

Input

The first line contains integer m (1 ≤ m ≤ 10⁵) — the number of stages to build a sequence.

Next m lines contain the description of the stages in the order they follow. The first number in the line is a type of stage (1 or 2). Type 1 means adding one number to the end of the sequence, in this case the line contains integer x_i (1 ≤ x_i ≤ 10⁵) — the number to add. Type 2 means copying a prefix of length l_i to the end c_i times, in this case the line further contains two integers l_i, c_i (1 ≤ l_i ≤ 10⁵, 1 ≤ c_i ≤ 10⁴), l_i is the length of the prefix, c_i is the number of copyings. It is guaranteed that the length of prefix l_i is never larger than the current length of the sequence.

The next line contains integer n (1 ≤ n ≤ 10⁵) — the number of elements Sereja is interested in. The next line contains the numbers of elements of the final sequence Sereja is interested in. The numbers are given in the strictly increasing order. It is guaranteed that all numbers are strictly larger than zero and do not exceed the length of the resulting sequence. Consider the elements of the final sequence numbered starting from 1from the beginning to the end of the sequence.

Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64dspecifier.

Output

Print the elements that Sereja is interested in, in the order in which their numbers occur in the input.

Examples

input

6
1 1
1 2
2 2 1
1 3
2 5 2
1 4
16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

output

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

題目大意：生成一個數組，有兩種操作，1  x 表示在數組後加上 x ，2 l c 表示將此時數組的前 l 個複製 c 次加到數組末尾。最後升序查詢數組元素

思路：顯然，如果不停的複製的話數組是存不下的。最多有m（1e5）次操作，也就是數組最多有1e5個數是新添加的，剩下的都是複製出來的，那麼只要將複製的部分摺疊式地存爲1個元素就行了。第一次使用 lower_bound（a，a+n，x）- a 表示返回a中第一個大於等於x的元素地址，代替了二分很方便啊。之前寫直接暴力遍歷數組，結果 t 在了31，纔想到了用二分搜索。果然，我還是太弱了。（這題寫了好久，終於a了，好想哭啊啊啊）

#include <bits/stdc++.h>
#define manx 100005
typedef long long ll;
using namespace std;
ll m,k,c;
ll a[manx];
bool f[manx];
ll len=1,n,x,num[manx];
ll solve(ll x)
{
    ll k=lower_bound(num,num+m+1,x)-num;  //返回num中第一個>=x的數的下標
    if(f[k]) return a[k];
    x = (x-num[k-1]) % a[k];  //第x個和(x-num[k-1])%a[k]個等價
    if (x) return solve(x);
    else return solve(a[k]);
}
int main()
{
    memset(f,true,sizeof(f));
    scanf("%I64d",&m);
    for (int i=1; i<=m; i++){
        scanf("%I64d",&k);
        if(k==1){
            scanf("%I64d",&a[i]);
            num[i]=len++;
        }
        else if (k==2){
            scanf("%I64d%I64d",&a[i],&c);
            len+=a[i]*c;
            f[i]=false;  //表示複製摺疊部分
            num[i]=len-1;
        }
    }
    scanf("%I64d",&n);
    ll i=1;
    while(n--){
        scanf("%I64d",&x);
        while(i<=m){  //升序查詢(後來覺得這步沒有必要,直接solve())
            if(num[i] == x && f[i]){
                printf("%I64d",a[i]);
                n ? printf(" "):printf("\n");
                i++;
                break;
            }
            else if(num[i] >= x){
                ll ans=solve(x);
                printf("%I64d",ans);
                n ? printf(" "):printf("\n");
                break;
            }
            else i++;
        }
    }
    return 0;
}