#ifndef LOCAL
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize ("-Ofast")
#pragma GCC optimize ("unroll-loops")
#endif

#include <bits/stdc++.h>
using namespace std;

using ll=long long;
//#define int ll

//fast IO by yosupo
//sc.read(string) だと append される
struct Scanner {
    FILE* fp = nullptr;
    char line[(1 << 15) + 1];
    size_t st = 0, ed = 0;
    void reread() {
        memmove(line, line + st, ed - st);
        ed -= st;
        st = 0;
        ed += fread(line + ed, 1, (1 << 15) - ed, fp);
        line[ed] = '\0';
    }
    bool succ() {
        while (true) {
            if (st == ed) {
                reread();
                if (st == ed) return false;
            }
            while (st != ed && isspace(line[st])) st++;
            if (st != ed) break;
        }
        if (ed - st <= 50) reread();
        return true;
    }
    template <class T, enable_if_t<is_same<T, string>::value, int> = 0>
    bool read_single(T& ref) {
        if (!succ()) return false;
        while (true) {
            size_t sz = 0;
            while (st + sz < ed && !isspace(line[st + sz])) sz++;
            ref.append(line + st, sz);
            st += sz;
            if (!sz || st != ed) break;
            reread();
        }
        return true;
    }
    template <class T, enable_if_t<is_integral<T>::value, int> = 0>
    bool read_single(T& ref) {
        if (!succ()) return false;
        bool neg = false;
        if (line[st] == '-') {
            neg = true;
            st++;
        }
        ref = T(0);
        while (isdigit(line[st])) {
            ref = 10 * ref + (line[st++] - '0');
        }
        if (neg) ref = -ref;
        return true;
    }
    template <class T> bool read_single(vector<T>& ref) {
        for (auto& d : ref) {
            if (!read_single(d)) return false;
        }
        return true;
    }
    void read() {}
    template <class H, class... T> void read(H& h, T&... t) {
        bool f = read_single(h);
        assert(f);
        read(t...);
    }
    Scanner(FILE* _fp) : fp(_fp) {}
};

struct Printer {
  public:
    template <bool F = false> void write() {}
    template <bool F = false, class H, class... T>
    void write(const H& h, const T&... t) {
        if (F) write_single(' ');
        write_single(h);
        write<true>(t...);
    }
    template <class... T> void writeln(const T&... t) {
        write(t...);
        write_single('\n');
    }

    Printer(FILE* _fp) : fp(_fp) {}
    ~Printer() { flush(); }

  private:
    static constexpr size_t SIZE = 1 << 15;
    FILE* fp;
    char line[SIZE], small[50];
    size_t pos = 0;
    void flush() {
        fwrite(line, 1, pos, fp);
        pos = 0;
    }
    void write_single(const char& val) {
        if (pos == SIZE) flush();
        line[pos++] = val;
    }
    template <class T, enable_if_t<is_integral<T>::value, int> = 0>
    void write_single(T val) {
        if (pos > (1 << 15) - 50) flush();
        if (val == 0) {
            write_single('0');
            return;
        }
        if (val < 0) {
            write_single('-');
            val = -val;  // todo min
        }
        size_t len = 0;
        while (val) {
            small[len++] = char('0' + (val % 10));
            val /= 10;
        }
        for (size_t i = 0; i < len; i++) {
            line[pos + i] = small[len - 1 - i];
        }
        pos += len;
    }
    void write_single(const string& s) {
        for (char c : s) write_single(c);
    }
    void write_single(const char* s) {
        size_t len = strlen(s);
        for (size_t i = 0; i < len; i++) write_single(s[i]);
    }
    template <class T> void write_single(const vector<T>& val) {
        auto n = val.size();
        for (size_t i = 0; i < n; i++) {
            if (i) write_single(' ');
            write_single(val[i]);
        }
    }
    void write_single(long double d){
        {
            long long v=d;
            write_single(v);
            d-=v;
        }
        write_single('.');
        for(int _=0;_<8;_++){
            d*=10;
            long long v=d;
            write_single(v);
            d-=v;
        }
    }
};

Scanner sc(stdin);
Printer pr(stdout);

#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define gnr(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define per(i,b) gnr(i,0,b)
#define pb push_back
#define eb emplace_back
#define a first
#define b second
#define bg begin()
#define ed end()
#define all(x) x.bg,x.ed
#define si(x) int(x.size())
#ifdef LOCAL
#define dmp(x) cerr<<__LINE__<<" "<<#x<<" "<<x<<endl
#else
#define dmp(x) void(0)
#endif

template<class t,class u> bool chmax(t&a,u b){if(a<b){a=b;return true;}else return false;}
template<class t,class u> bool chmin(t&a,u b){if(b<a){a=b;return true;}else return false;}

template<class t> using vc=vector<t>;
template<class t> using vvc=vc<vc<t>>;

using pi=pair<int,int>;
using vi=vc<int>;

template<class t,class u>
ostream& operator<<(ostream& os,const pair<t,u>& p){
    return os<<"{"<<p.a<<","<<p.b<<"}";
}

template<class t> ostream& operator<<(ostream& os,const vc<t>& v){
    os<<"{";
    for(auto e:v)os<<e<<",";
    return os<<"}";
}

#define mp make_pair
#define mt make_tuple
#define one(x) memset(x,-1,sizeof(x))
#define zero(x) memset(x,0,sizeof(x))
#ifdef LOCAL
void dmpr(ostream&os){os<<endl;}
template<class T,class... Args>
void dmpr(ostream&os,const T&t,const Args&... args){
    os<<t<<" ";
    dmpr(os,args...);
}
#define dmp2(...) dmpr(cerr,__LINE__,##__VA_ARGS__)
#else
#define dmp2(...) void(0)
#endif

using uint=unsigned;
using ull=unsigned long long;

template<class t,size_t n>
ostream& operator<<(ostream&os,const array<t,n>&a){
    return os<<vc<t>(all(a));
}

template<int i,class T>
void print_tuple(ostream&,const T&){
}

template<int i,class T,class H,class ...Args>
void print_tuple(ostream&os,const T&t){
    if(i)os<<",";
    os<<get<i>(t);
    print_tuple<i+1,T,Args...>(os,t);
}

template<class ...Args>
ostream& operator<<(ostream&os,const tuple<Args...>&t){
    os<<"{";
    print_tuple<0,tuple<Args...>,Args...>(os,t);
    return os<<"}";
}

template<class t>
void print(t x,int suc=1){
    cout<<x;
    if(suc==1)
        cout<<"\n";
    if(suc==2)
        cout<<" ";
}

ll read(){
    ll i;
    cin>>i;
    return i;
}

vi readvi(int n,int off=0){
    vi v(n);
    rep(i,n)v[i]=read()+off;
    return v;
}

pi readpi(int off=0){
    int a,b;cin>>a>>b;
    return pi(a+off,b+off);
}

template<class t,class u>
void print(const pair<t,u>&p,int suc=1){
    print(p.a,2);
    print(p.b,suc);
}

template<class T>
void print(const vector<T>&v,int suc=1){
    rep(i,v.size())
        print(v[i],i==int(v.size())-1?suc:2);
}

string readString(){
    string s;
    cin>>s;
    return s;
}

template<class T>
T sq(const T& t){
    return t*t;
}

//#define CAPITAL
void yes(bool ex=true){
    #ifdef CAPITAL
    cout<<"YES"<<"\n";
    #else
    cout<<"Yes"<<"\n";
    #endif
    if(ex)exit(0);
    #ifdef LOCAL
    cout.flush();
    #endif
}
void no(bool ex=true){
    #ifdef CAPITAL
    cout<<"NO"<<"\n";
    #else
    cout<<"No"<<"\n";
    #endif
    if(ex)exit(0);
    #ifdef LOCAL
    cout.flush();
    #endif
}
void possible(bool ex=true){
    #ifdef CAPITAL
    cout<<"POSSIBLE"<<"\n";
    #else
    cout<<"Possible"<<"\n";
    #endif
    if(ex)exit(0);
    #ifdef LOCAL
    cout.flush();
    #endif
}
void impossible(bool ex=true){
    #ifdef CAPITAL
    cout<<"IMPOSSIBLE"<<"\n";
    #else
    cout<<"Impossible"<<"\n";
    #endif
    if(ex)exit(0);
    #ifdef LOCAL
    cout.flush();
    #endif
}

constexpr ll ten(int n){
    return n==0?1:ten(n-1)*10;
}

const ll infLL=LLONG_MAX/3;

#ifdef int
const int inf=infLL;
#else
const int inf=INT_MAX/2-100;
#endif

int topbit(signed t){
    return t==0?-1:31-__builtin_clz(t);
}
int topbit(ll t){
    return t==0?-1:63-__builtin_clzll(t);
}
int botbit(signed a){
    return a==0?32:__builtin_ctz(a);
}
int botbit(ll a){
    return a==0?64:__builtin_ctzll(a);
}
int popcount(signed t){
    return __builtin_popcount(t);
}
int popcount(ll t){
    return __builtin_popcountll(t);
}
bool ispow2(int i){
    return i&&(i&-i)==i;
}
ll mask(int i){
    return (ll(1)<<i)-1;
}

bool inc(int a,int b,int c){
    return a<=b&&b<=c;
}

template<class t> void mkuni(vc<t>&v){
    sort(all(v));
    v.erase(unique(all(v)),v.ed);
}

ll rand_int(ll l, ll r) { //[l, r]
    #ifdef LOCAL
    static mt19937_64 gen;
    #else
    static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
    #endif
    return uniform_int_distribution<ll>(l, r)(gen);
}

template<class t>
void myshuffle(vc<t>&a){
    rep(i,si(a))swap(a[i],a[rand_int(0,i)]);
}

template<class t>
int lwb(const vc<t>&v,const t&a){
    return lower_bound(all(v),a)-v.bg;
}

vvc<int> readGraph(int n,int m){
    vvc<int> g(n);
    rep(i,m){
        int a,b;
        cin>>a>>b;
        //sc.read(a,b);
        a--;b--;
        g[a].pb(b);
        g[b].pb(a);
    }
    return g;
}

vvc<int> readTree(int n){
    return readGraph(n,n-1);
}

/*
//N() が単位元
//VERIFY: yosupo
//CF407E
template<class N>
struct segtree{
    vc<N> x;
    int s;
    segtree(){}
    template<class t>
    segtree(vc<t> a){
        int n=a.size();
        s=1;
        while(s<n){s*=2;}
        x.resize(s*2);
        rep(i,n)
            x[s+i]=N(a[i]);
        gnr(i,1,s)
            x[i]=N::merge(x[i*2],x[i*2+1]);
    }
    void resize(int n){
        s=1;
        while(s<n){s*=2;}
        x.assign(s*2,N());
    }
    void set(int i,const N&t){
        i+=s;
        x[i]=t;
        while(i>>=1)x[i]=N::merge(x[i*2],x[i*2+1]);
    }
    N composite(int b,int e){
        assert(b<=e);
        N lf,rt;
        for(int l=b+s,r=e+s;l<r;l>>=1,r>>=1){
            if (l&1){
                lf=N::merge(lf,x[l]);
                l++;
            }
            if (r&1){
                r--;
                rt=N::merge(x[r],rt);
            }
        }
        return N::merge(lf,rt);
    }
    N getall(){
        return x[1];
    }
    //UTPC2020E
    //n 超えるかもしれない
    template <class F,class... Args>
    pair<int,N> max_right(int l,F f,Args&&... args){
        assert(0<=l&&l<=s);
        if(l==s)return mp(s,N());
        l+=s;

        N sm;
        assert((sm.*f)(forward<Args>(args)...));
        do {
            while (l % 2 == 0) l >>= 1;
            if (!(N::merge(sm,x[l]).*f)(forward<Args>(args)...)){
                while (l < s) {
                    l = (2 * l);
                    N tmp=N::merge(sm,x[l]);
                    if ((tmp.*f)(forward<Args>(args)...)) {
                        sm = tmp;
                        l++;
                    }
                }
                return mp(l - s,sm);
            }
            sm = N::merge(sm, x[l]);
            l++;
        } while ((l & -l) != l);
        return mp(s,sm);
    }
    //UTPC2020E
    template <class F,class... Args>
    pair<int,N> min_left(int r,F f,Args&&... args){
        assert((N().*f)(forward<Args>(args)...));
        assert(0<=r&&r<=s);
        if(r==0)return mp(0,N());
        r+=s;
        N sm;
        do {
            r--;
            while (r > 1 && (r % 2)) r >>= 1;
            if (!(N::merge(x[r],sm).*f)(forward<Args>(args)...)) {
                while (r < s) {
                    r = (2 * r + 1);
                    N tmp=N::merge(x[r],sm);
                    if ((tmp.*f)(forward<Args>(args)...)) {
                        sm = tmp;
                        r--;
                    }
                }
                return mp(r + 1 - s,sm);
            }
            sm = N::merge(x[r], sm);
        } while ((r & -r) != r);
        return mp(0,sm);
    }
};

template<class N>
struct Point1D{
    segtree<N> seg;
    vi pos;
    Point1D(){}
    void clear(){
        seg.clear();
        pos.clear();
    }
    void addp(int p){
        pos.pb(p);
    }
    void init(){
        mkuni(pos);
        //seg=segtree<N>(vc<N>(si(pos)));
        seg.resize(si(pos));
    }
    int idx(int p){
        return lwb(pos,p);
    }
    void setv(int p,N v){
        seg.set(idx(p),v);
    }
    N get(int b,int e){
        return seg.composite(idx(b),idx(e));
    }
};

struct MaxNode{
    ll v;
    MaxNode(ll vv=-infLL):v(vv){}
    static MaxNode merge(const MaxNode&a,const MaxNode&b){
        return MaxNode(max(a.v,b.v));
    }
};
*/

const int nmax=110010;

vc<pi> t[nmax];
int in[nmax],out[nmax],iohead;
ll dep[nmax];

void dfs(int v,int p,ll d){
    dep[v]=d;
    in[v]=iohead++;
    for(auto [to,cost]:t[v])if(to!=p){
        dfs(to,v,d+cost);
    }
    out[v]=iohead;
}

/*
struct Unko{
    int s;
    vc<Point1D<MaxNode>> z;
    Unko(int n){
        s=1;
        while(s<n)s*=2;
        z.resize(s*2);
    }
    void addrng(int l,int r,int y){
        for(l+=s,r+=s;l<r;l>>=1,r>>=1){
            if (l&1){
                //ae(v,y[l],w);
                z[l].addp(y);
                l++;
            }
            if (r&1){
                r--;
                //ae(v,y[r],w);
                z[r].addp(y);
            }
        }
    }
    void init(){
        rng(i,1,s*2){
            z[i].init();
        }
    }
    void setval(int l,int r,int y,ll val){
        for(l+=s,r+=s;l<r;l>>=1,r>>=1){
            if (l&1){
                //ae(v,y[l],w);
                z[l].setv(y,val);
                l++;
            }
            if (r&1){
                r--;
                //ae(v,y[r],w);
                z[r].setv(y,val);
            }
        }
    }
    ll getval(int x,int l,int r){
        x+=s;
        ll ans=-infLL;
        while(x){
            chmax(ans,z[x].get(l,r).v);
            x>>=1;
        }
        return ans;
    }
};
*/

int col[nmax];

bool dbg=false;

struct Unko{
    int l,r,i;
} pool[nmax*40*2];

int phead=0;
Unko* getpool(int len){
    Unko* res=pool+phead;
    phead+=len;
    return res;
}

void slv(){
    int n,q;
    if(dbg){
        n=110000;
        q=110000;
    }else{
        sc.read(n,q);
    }
    rep(_,n-1){
        int u,v,w;
        if(dbg){
            u=rand_int(0,_);
            v=_;
            w=rand_int(1,ten(9));
        }else{
            sc.read(u,v,w);
            u--;v--;
        }
        t[u].eb(v,w);
        t[v].eb(u,w);
    }
    dfs(0,-1,0);
    /*
    rep(i,q){
        int kind;
        if(dbg){
            kind=rand_int(0,1);
        }else{
            sc.read(kind);
        }
        if(kind==0){
            int u,x;
            if(dbg){
                u=rand_int(0,n-1);
                x=rand_int(1,n);
            }else{
                sc.read(u,x);u--;
            }
            col[u]=x;
        }else if(kind==1){
            int u,l,r,x;
            if(dbg){
                u=rand_int(0,n-1);
                l=rand_int(1,n);
                r=rand_int(l,n);
                x=rand_int(1,n);
            }else{
                sc.read(u,l,r,x);u--;
            }
            ll minus=-infLL;
            rep(v,n)if(in[v]<=in[u]&&in[u]<=out[v]&&l<=col[v]&&col[v]<=r&&col[v]%x==0)
                chmax(minus,dep[v]);
            if(minus<0){
                pr.writeln("Impossible!");
            }else{
                pr.writeln(dep[u]-minus);
            }
        }else assert(false);
    }*/
    vvc<pi> add(n+1);
    using Q=tuple<int,int,int,int>;
    vvc<Q> ask(n+1);
    vc<bool> isask(q);
    vc<ll> ansbase(q),ansminus(q,-infLL);
    rep(_,q){
        int kind;
        if(dbg){
            kind=rand_int(0,1);
        }else{
            sc.read(kind);
        }
        if(kind==0){
            int u,x;
            if(dbg){
                u=rand_int(0,n-1);
                x=rand_int(1,n);
            }else{
                sc.read(u,x);u--;
            }
            add[x].eb(_,u);
        }else if(kind==1){
            isask[_]=true;
            int u,l,r,x;
            if(dbg){
                u=rand_int(0,n-1);
                l=rand_int(1,n);
                r=rand_int(l,n);
                x=rand_int(1,n);
            }else{
                sc.read(u,l,r,x);u--;
            }
            r++;
            l=(l+x-1)/x*x;
            r=(r+x-1)/x*x;
            if(l<r)ask[x].eb(_,u,l,r);
            ansbase[_]=dep[u];
        }else assert(false);
    }

    auto roudou=[&](Unko*p,int len){
        static vi vs;
        static vc<ll> buf;

        vs.clear();
        rep(i,len){
            if(p[i].r==-1)vs.pb(p[i].l);
        }
        mkuni(vs);

        int s=1;
        while(s<si(vs))s*=2;

        buf.assign(s*2,-infLL);

        rep(i,len){
            if(p[i].r==-1){
                for(int x=s+lwb(vs,p[i].l);x;x>>=1)
                    chmax(ansminus[p[i].i],buf[x]);
            }else{
                for(int l=lwb(vs,p[i].l)+s,r=lwb(vs,p[i].r)+s;l<r;l>>=1,r>>=1){
                    if (l&1){
                        //ae(v,y[l],w);
                        chmax(buf[l],dep[p[i].i]);
                        l++;
                    }
                    if (r&1){
                        r--;
                        //ae(v,y[r],w);
                        chmax(buf[r],dep[p[i].i]);
                    }
                }
            }
        }
    };

    struct Query{
        int _,u,l,r;
        bool operator<(const Query&rhs)const{return _<rhs._;}
    };
    vc<Query> work;
    vi vs,lens;
    vc<Unko*> ps;
    rng(x,1,n+1)if(si(ask[x])){
        vs.clear();
        for(auto [_,u,l,r]:ask[x]){
            vs.pb(l);
            vs.pb(r);
        }
        mkuni(vs);

        work.clear();
        for(int y=vs.front();y<vs.back();y+=x){
            for(auto [_,u]:add[y]){
                work.pb({_,u,int(upper_bound(all(vs),y)-vs.bg-1),-1});
            }
        }
        for(auto [_,u,l,r]:ask[x]){
            work.pb({_,u,lwb(vs,l),lwb(vs,r)});
        }
        sort(all(work));

        int s=1;
        while(s<si(vs)-1)s*=2;
        lens.assign(s*2,0);

        for(auto w:work){
            if(w.r==-1){
                for(int i=s+w.l;i;i>>=1){
                    lens[i]++;
                }
            }else{
                for(int l=w.l+s,r=w.r+s;l<r;l>>=1,r>>=1){
                    if (l&1){
                        lens[l]++;
                        l++;
                    }
                    if (r&1){
                        r--;
                        lens[r]++;
                    }
                }
            }
        }

        ps.resize(s*2);
        rng(i,1,s*2){
            ps[i]=getpool(lens[i]);
            lens[i]=0;
        }

        for(auto w:work){
            if(w.r==-1){
                for(int i=s+w.l;i;i>>=1){
                    ps[i][lens[i]++]={in[w.u],out[w.u],w.u};
                }
            }else{
                for(int l=w.l+s,r=w.r+s;l<r;l>>=1,r>>=1){
                    if (l&1){
                        ps[l][lens[l]++]={in[w.u],-1,w._};
                        l++;
                    }
                    if (r&1){
                        r--;
                        ps[r][lens[r]++]={in[w.u],-1,w._};
                    }
                }
            }
        }

        rng(i,1,s*2)roudou(ps[i],lens[i]);
    }

    rep(i,q)if(isask[i]){
        if(ansminus[i]<0){
            pr.writeln("Impossible!");
        }else{
            pr.writeln(ansbase[i]-ansminus[i]);
        }
    }
}

signed main(){
    cin.tie(0);
    ios::sync_with_stdio(0);
    cout<<fixed<<setprecision(20);

    //int t;cin>>t;rep(_,t)
    slv();
}