Random Numbers Gym

Tamref love random numbers, but he hates recurrent relations, Tamref thinks that mainstream random generators like the linear congruent generator suck. That's why he decided to invent his own random generator.

As any reasonable competitive programmer, he loves trees. His generator starts with a tree with numbers on each node. To compute a new random number, he picks a rooted subtree and multiply the values of each node on the subtree. He also needs to compute the number of divisors of the generated number (because of cryptographical applications).

In order to modify the tree (and hence create different numbers on the future), Tamref decided to perform another query: pick a node, and multiply its value by a given number.

Given a initial tree T, where T_u corresponds to the value on the node u, the operations can be summarized as follows:

• RAND: Given a node u compute  and count its divisors, where T(u) is the set of nodes that belong to the subtree rooted at u.
• SEED: Given a node u and a number x, multiply T_u by x.

Tamref is quite busy trying to prove that his method indeed gives integers uniformly distributed, in the meantime, he wants to test his method with a set of queries, and check which numbers are generated. He wants you to write a program that given the tree, and some queries, prints the generated numbers and count its divisors.

Tamref has told you that the largest prime factor of both T_u and x is at most the Tamref's favourite prime: 13. He also told you that the root of T is always node 0.

The figure shows the sample test case. The numbers inside the squares are the values on each node of the tree. The subtree rooted at node 1 is colored. The RAND query for the subtree rooted at node 1 would generate 14400, which has 63 divisors.

Input

The first line is an integer n (1 ≤ n ≤ 10⁵), the number of nodes in the tree T. Then there are n - 1 lines, each line contains two integers u and v (0 ≤ u, v < n) separated by a single space, it represents that u is a parent of v in T. The next line contains n integers, where the i - th integer corresponds to T_i (1 ≤ T_i ≤ 10⁹). The next line contains a number Q (1 ≤ Q ≤ 10⁵), the number of queries. The final Q lines contain a query per line, in the form "RAND u" or "SEED u x" (0 ≤ u < n, 1 ≤ x ≤ 10⁹).

Output

For each RAND query, print one line with the generated number and its number of divisors separated by a space. As this number can be very long, the generated number and its divisors must be printed modulo 10⁹ + 7.

Example

Input

8
0 1
0 2
1 3
2 4
2 5
3 6
3 7
7 3 10 8 12 14 40 15
3
RAND 1
SEED 1 13
RAND 1

Output

14400 63
187200 126

题意：

　　给你一棵有n个节点的树，根节点始终为0，有两种操作：

　　　　1.RAND：查询以u为根节点的子树上的所有节点的权值的乘积x，及x的因数个数。

　　　　2.SEED：将节点u的权值乘以x。

看清楚题目啊  素因子最大为13

知道这个用dfs序处理一下 然后建立线段树就OK了

这题还用来 唯一分解定理  https://www.cnblogs.com/qldabiaoge/p/8647130.html

再用快速幂处理一下就搞定了

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>
#include <set>
#include <iostream>
#include <map>
#include <stack>
#include <string>
#include <vector>
#include <bits/stdc++.h>
#define  pi acos(-1.0)
#define  eps 1e-6
#define  fi first
#define  se second
#define  lson        l,m,rt<<1
#define  rson        m+1,r,rt<<1|1
#define  rtl         rt<<1
#define  rtr         rt<<1|1
#define  bug         printf("******
")
#define  mem(a,b)    memset(a,b,sizeof(a))
#define  fuck(x)     cout<<"["<<x<<"]"<<endl
#define  f(a)        a*a
#define  sf(n)       scanf("%d", &n)
#define  sff(a,b)    scanf("%d %d", &a, &b)
#define  sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)
#define  sffff(a,b,c,d) scanf("%d %d %d %d", &a, &b, &c, &d)
#define  pf          printf
#define  FRE(i,a,b)  for(i = a; i <= b; i++)
#define  FREE(i,a,b) for(i = a; i >= b; i--)
#define  FRL(i,a,b)  for(i = a; i < b; i++)
#define  FRLL(i,a,b) for(i = a; i > b; i--)
#define  FIN         freopen("DATA.txt","r",stdin)
#define  gcd(a,b)    __gcd(a,b)
#define  lowbit(x)   x&-x
#pragma  comment (linker,"/STACK:102400000,102400000")
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const int INF = 0x7fffffff;
const LL LLINF = 0x3f3f3f3f3f3f3f3fll;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, m, x, y, tot, dfscnt, head[maxn], L[maxn], R[maxn], val[maxn];
int prime[6] = {2, 3, 5, 7, 11, 13}, cnt[10], ans[10];
struct Edge {
    int v, nxt;
} edge[maxn << 2];
void init() {
    tot = 0;
    mem(head, -1);
}
void add(int u, int v) {
    edge[tot].v = v;
    edge[tot].nxt = head[u];
    head[u] = tot++;
}
void dfs(int u, int fa) {
    L[u] = ++dfscnt;
    for (int i = head[u]; ~i ; i = edge[i].nxt) {
        int v = edge[i].v;
        if (v != fa) dfs(v, u);
    }
    R[u] = dfscnt;
}
struct node {
    int l, r, num[6];
    int mid() {
        return (l + r) >> 1;
    }
} tree[maxn << 2];
void pushup(int rt) {
    for (int i = 0 ; i < 6 ; i++)
        tree[rt].num[i] = (tree[rtl].num[i] + tree[rtr].num[i]) % mod;
}
void build(int l, int r, int rt) {
    tree[rt].l = l, tree[rt].r = r;
    mem(tree[rt].num, 0);
    if (l == r) {
        for (int i = 0 ; i < 6 ; i++) {
            while(val[l] % prime[i] == 0) {
                val[l] /= prime[i];
                tree[rt].num[i]++;
            }
        }
        return ;
    }
    int m = (l + r) >> 1;
    build(l, m, rtl);
    build(m + 1, r, rtr);
    pushup(rt);
}
void update(int pos, int rt) {
    if (tree[rt].l == pos && tree[rt].r == pos) {
        for (int i = 0 ; i < 6 ; i++)
            tree[rt].num[i] = (tree[rt].num[i] + cnt[i]) % mod;
        return ;
    }
    int m = tree[rt].mid();
    if (pos <= m) update(pos, rtl);
    else update(pos, rtr);
    pushup(rt);
}
void query(int L, int R, int rt) {
    if (tree[rt].l == L && tree[rt].r == R) {
        for (int i = 0 ; i < 6 ; i++)
            ans[i] = (ans[i] + tree[rt].num[i]) % mod;
        return ;
    }
    int m = tree[rt].mid();
    if (R <= m) query(L, R, rtl);
    else if (L > m) query(L, R, rtr);
    else {
        query(L, m, rtl);
        query(m + 1, R, rtr);
    }
}
int expmod(int a, int b) {
    int ret = 1;
    while(b) {
        if(b & 1) ret = 1LL * ret * a % mod;
        a = 1LL * a * a % mod;
        b = b >> 1;
    }
    return ret;
}
int main() {
    sf(n);
    init();
    for (int i = 1 ; i < n ; i++) {
        int u, v;
        sff(u, v);
        u++, v++;
        add(u, v);
        add(v, u);
    }
    dfs(1, -1);
    for (int i = 1 ; i <= n ; i++) {
        sf(x);
        val[L[i]] = x;
    }
    build(1, n, 1);
    sf(m);
    while(m--) {
        char op[10];
        scanf("%s", op);
        if (op[0] == 'R') {
            sf(x);
            x++;
            mem(ans, 0);
            query(L[x], R[x], 1);
            LL ans1 = 1, ans2 = 1;
            for (int i = 0 ; i < 6 ; i++) {
                ans1 = (ans1 * expmod(prime[i], ans[i]) % mod) % mod;
                ans2 = (ans2*((ans[i]+1)%mod)) % mod;
            }
            printf("%lld %lld
", ans1, ans2);
        } else {
            sff(x, y);
            x++;
            for (int i = 0 ; i < 6 ; i++) {
                cnt[i] = 0;
                while(y % prime[i] == 0) {
                    cnt[i]++;
                    y /= prime[i];
                }
            }
            update(L[x], 1);
        }
    }
    return 0;
}