# include <bits/stdc++.h>

using namespace std;

namespace kh {
  constexpr int P(19'940'417);
  inline namespace src {
    template <typename T>
      constexpr auto cmin(T& a, T const& b) {
        if (b < a) return pair<T&, bool>(a = b, true);
        else return pair<T&, bool>(a, false);
      }
    template <typename T>
      constexpr auto cmax(T& a, T const& b) {
        if (a < b) return pair<T&, bool>(a = b, true);
        else return pair<T&, bool>(a, false);
      }
    template <typename T>
      constexpr auto cminmax(T& a, T& b) {
        bool const swp(b < a ? swap(a, b), true : false);
        return make_pair(pair<T&, T&>(a, b), swp);
      }
    template <typename T, class Compare>
      constexpr auto cmin(T& a, T const& b, Compare comp) {
        if (comp(b, a)) return pair<T&, bool>(a = b, true);
        else return pair<T&, bool>(a, false);
      }
    template <typename T, class Compare>
      constexpr auto cmax(T& a, T const& b, Compare comp) {
        if (comp(a, b)) return pair<T&, bool>(a = b, true);
        else return pair<T&, bool>(a, false);
      }
    template <typename T, class Compare>
      constexpr auto cminmax(T& a, T& b, Compare comp) {
        bool const swp(comp(b, a) ? swap(a, b), true : false);
        return make_pair(pair<T&, T&>(a, b), swp);
      }
    template <typename T>
      constexpr int sgn(T const x)
      { return (x > 0) - (x < 0); }
    template <typename T>
      struct frac {
        T num, den;
        constexpr frac(T const n = 0, T const d = 1)
          : num(n / __gcd(n, d)), den(d / __gcd(n, d))
        { assert(den), num *= sgn(den), den *= sgn(den); }
        constexpr frac& operator+=(frac const b) { return *this = *this + b; }
        constexpr frac& operator-=(frac const b) { return *this = *this - b; }
        constexpr frac& operator*=(frac const b) { return *this = *this * b; }
        constexpr frac& operator/=(frac const b) { return *this = *this / b; }
        constexpr frac& operator++() { return num += den, *this; }
        constexpr frac& operator--() { return num -= den, *this; }
        constexpr frac operator++(int) { return num += den, *this - 1; }
        constexpr frac operator--(int) { return num -= den, *this - 1; }
        constexpr frac operator+() const { return frac(+num, den); }
        constexpr frac operator-() const { return frac(-num, den); }
        friend constexpr frac operator+(frac const a, frac const b)
        { return frac(a.num * b.den + b.num * a.den, a.den * b.den); }
        friend constexpr frac operator-(frac const a, frac const b)
        { return frac(a.num * b.den - b.num * a.den, a.den * b.den); }
        friend constexpr frac operator*(frac const a, frac const b)
        { return frac(a.num * b.num, a.den * b.den); }
        friend constexpr frac operator/(frac const a, frac const b)
        { return frac(a.num * b.den, a.den * b.num); }
        friend constexpr bool operator==(frac const a, frac const b)
        { return a.num * b.den == b.num * a.den; }
        friend constexpr bool operator!=(frac const a, frac const b)
        { return a.num * b.den != b.num * a.den; }
        friend constexpr bool operator<(frac const a, frac const b)
        { return a.num * b.den < b.num * a.den; }
        friend constexpr bool operator>(frac const a, frac const b)
        { return a.num * b.den > b.num * a.den; }
        friend constexpr bool operator<=(frac const a, frac const b)
        { return a.num * b.den <= b.num * a.den; }
        friend constexpr bool operator>=(frac const a, frac const b)
        { return a.num * b.den >= b.num * a.den; }
      };
    constexpr int pow(int a, int n) {
      int r(1);
      while (n) {
        r = 1l * r * (n & 1 ? a : 1) % P;
        a = 1l * a * a % P, n >>= 1;
      }
      return r;
    }
    template <typename T, int N>
      class fenwick1 {
        T v[N + 1];
        public:
        constexpr fenwick1() : v{} {}
        constexpr void add(int x, T const y)
        { while (x <= N) v[x] += y, x += x & -x; }
        constexpr T sum(int x) const
        { T r(0); while (x) r += v[x], x &= x - 1; return r; }
        constexpr T sum(int const l, int const r) const
        { return sum(r) - sum(l); }
        constexpr T at(int const x) const
        { return sum(x) - sum(x - 1); }
      };
  }
  constexpr int N(150'000);
  constexpr int M(750'000);
  class dsuk {
    int mo[N + 1];
    int sz[N + 1];
    public:
    void init(int const n) {
      iota(mo + 1, mo + n + 1, 1);
      fill(sz + 1, sz + n + 1, 1);
    }
    int find(int const x)
    { return mo[x] == x ? x : mo[x] = find(mo[x]); }
    bool merge(int x, int y) {
      if ((x = find(x)) == (y = find(y))) return false;
      if (sz[x] < sz[y]) swap(x, y);
      return mo[y] = x, sz[x] += sz[y], sz[y] = 0, true;
    }
  };
  class dsuc {
    int mo[N + 1];
    public:
    void init(int const n) { iota(mo + 1, mo + n + 1, 1); }
    int find(int const x) { return mo[x] == x ? x : mo[x] = find(mo[x]); }
    void merge(int const x, int const y) { mo[find(x)] = find(y); }
  };
  struct event { int p, a, b; bool mst; };
  struct node { vector<int> n; int l, r, s, m, g; int v; };
  int n, m, idx;
  int a[N + 1];
  event e[M + 1];
  node v[N + 1];
  dsuk uk;
  dsuc uc;
  fenwick1<int, N + 1> bit;
  void se0(int const x, int const mo) {
    v[x].l = idx, v[x].s = 1, v[x].m = mo;
    for (int const y : v[x].n) if (y != mo)
      se0(y, x), v[x].s += v[y].s;
    v[x].r = ++idx;
  }
  void se1(int const x, int const mo) {
    v[x].g = v[x].g ? v[x].g : x;
    int d(0);
    for (int const y : v[x].n) if (y != mo)
      d = v[y].s > v[d].s ? y : d;
    if (d) v[d].g = v[x].g, se1(d, x);
    for (int const y : v[x].n)
      if (y != mo && y != d) se1(y, x);
  }
  inline int lca(int x, int y) {
    while (v[x].g != v[y].g) {
      if (v[v[x].g].r < v[v[y].g].r) x = v[v[x].g].m;
      if (v[v[y].g].r < v[v[x].g].r) y = v[v[y].g].m;
    }
    return v[x].r < v[y].r ? y : x;
  }
  inline void merge(int const x) {
    int const val(v[x].v);
    bit.add(v[x].l + 1, -val);
    bit.add(v[x].r + 1, +val);
    bit.add(v[uc.find(v[x].m)].l + 1, +val);
    bit.add(v[uc.find(v[x].m)].r + 1, -val);
    v[uc.find(v[x].m)].v += v[x].v, v[x].v = 0;
    uc.merge(x, v[x].m);
  }
  void main() {
    cin >> n >> m, uk.init(n);
    for (int i(1); i <= n; ++i) cin >> a[i];
    for (int i(1); i <= m; ++i) cin >> e[i].p >> e[i].a >> e[i].b;
    for (int i(1); i <= m; ++i)
      if (e[i].p == 1 && uk.merge(e[i].a, e[i].b)) {
        e[i].mst = true;
        v[e[i].a].n.push_back(e[i].b);
        v[e[i].b].n.push_back(e[i].a);
      }
    for (int i(1); i <= n; ++i)
      if (!v[i].s) se0(i, 0), se1(i, 0);
    uk.init(n), uc.init(n);
    for (int i(1); i <= n; ++i) {
      v[i].v = a[i];
      bit.add(v[i].l + 1, +a[i]);
      bit.add(v[i].r + 1, -a[i]);
    }
    for (int i(1); i <= m; ++i) {
      auto const [p, a, b, mst](e[i]);
      switch (p) {
        case 1:
          if (mst) uk.merge(a, b);
          else while (uc.find(a) != uc.find(b)) {
            int const x(uc.find(a));
            int const y(uc.find(b));
            if (v[x].r < v[y].r) merge(x);
            if (v[y].r < v[x].r) merge(y);
          }
          break;
        case 2:
          bit.add(v[uc.find(a)].l + 1, b - kh::a[a]);
          bit.add(v[uc.find(a)].r + 1, kh::a[a] - b);
          v[uc.find(a)].v += b - kh::a[a], kh::a[a] = b;
          break;
        case 3:
          if (uk.find(a) != uk.find(b))
          { cout << -1 << '\n'; break; }
          int ans(0);
          ans += bit.sum(v[a].r);
          ans += bit.sum(v[b].r);
          ans -= 2 * bit.sum(v[lca(a, b)].r);
          ans += v[uc.find(lca(a, b))].v;
          cout << ans << '\n';
          break;
      }
    }
  }
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  int t(1);
  // cin >> t;
  for (int i(1); i <= t; ++i) kh::main();
}