You have a full binary tree having infinite levels.

Each node has an initial value. If a node has value x, then its left child has value 2·x and its right child has value 2·x + 1. 

The value of the root is 1. 

You need to answer Q queries. 

There are 3 types of queries: 

  1. Cyclically shift the values of all nodes on the same level as node with value X by K units. (The values/nodes of any other level are not affected).
  2. Cyclically shift the nodes on the same level as node with value X by K units. (The subtrees of these nodes will move along with them).
  3. Print the value of every node encountered on the simple path from the node with value X to the root.



Positive K implies right cyclic shift and negative K implies left cyclic shift. 

It is guaranteed that atleast one type 3 query is present.

Input

The first line contains a single integer Q (1 ≤ Q ≤ 105).

Then Q queries follow, one per line: 

  * Queries of type 1 and 2 have the following format: T X K (1 ≤ T ≤ 2; 1 ≤ X ≤ 1018; 0 ≤ |K| ≤ 1018), where T is type of the query.
  * Queries of type 3 have the following format: 3 X (1 ≤ X ≤ 1018).

Output

For each query of type 3, print the values of all nodes encountered in descending order.

Examples

Input

5
3 12
1 2 1
3 12
2 4 -1
3 8


Output

12 6 3 1 
12 6 2 1 
8 4 2 1 


Input

5
3 14
1 5 -3
3 14
1 3 1
3 14


Output

14 7 3 1 
14 6 3 1 
14 6 2 1 

Note

Following are the images of the first 4 levels of the tree in the first test case:

Original: 

<image>

After query 1 2 1: 

<image>

After query 2 4 -1: 

<image>
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class FullBinaryTreeQueries {
    
    int N = 63;
    
    long[] sz = new long[N];
    long[] fr = new long[N], to = new long[N];
    
    long[] v_shift = new long[N];
    long[] n_shift = new long[N];
    
    void solve() {
        for (int i = 0; i < N; i++) {
            sz[i] = 1L << i;
            fr[i] = 1L << i;
            to[i] = (1L << (i + 1)) - 1;
        }
        
        int Q = in.nextInt();
        while (Q-- > 0) {
            int T = in.nextInt();
            if (T == 1) {
                long x = in.nextLong(), k = in.nextLong();
                int l = findLevel(x);
                v_shift[l] = add(v_shift[l], k, sz[l]);
            } else if (T == 2) {
                long x = in.nextLong(), k = in.nextLong();
                int l = findLevel(x);
                n_shift[l] = add(n_shift[l], k, sz[l]);
            } else {
                long x = in.nextLong();
                int l = findLevel(x);
                long i = (findPos(x) + v_shift[l]) % sz[l];
                printPath(l, i);
            }
        }
    }
    
    void printPath(int l, long i) {
        if (l < 0) {
            out.println();
            return;
        }
        
        long x = calcVal(l, i);
        out.print(x + " ");
        
        long p = (i + n_shift[l]) / 2;
        printPath(l - 1, p);
    }
    
    // calc the value of the i-th node in level l
    long calcVal(int l, long i) {
        return fr[l] + (i - v_shift[l] + sz[l]) % sz[l];
    }
    
    // find the level of value x
    int findLevel(long x) {
        return 63 - Long.numberOfLeadingZeros(x);
    }
    
    // find the original position of the node of value x in its level
    long findPos(long x) {
        return x ^ Long.highestOneBit(x);
    }
    
    long add(long a, long b, long mod) {
        return (a + b % mod + mod) % mod;
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new FullBinaryTreeQueries().solve();
        out.close();
    }
    
    static FastScanner in;
    static PrintWriter out;
    
    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;
        
        public FastScanner(BufferedReader in) {
            this.in = in;
        }
        
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        
        public long nextLong() {
            return Long.parseLong(nextToken());
        }
        
        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
