#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline istream& operator>>(istream& fin, pair<T1, T2>& pr) {
  fin >> pr.first >> pr.second;
  return fin;
}
template <class T0, class T1, class T2>
inline istream& operator>>(istream& fin, tuple<T0, T1, T2>& t) {
  fin >> get<0>(t) >> get<1>(t) >> get<2>(t);
  return fin;
}
template <class T>
inline istream& operator>>(istream& fin, vector<T>& a) {
  for (auto& u : a) fin >> u;
  return fin;
}
template <class T, size_t n>
inline istream& operator>>(istream& fin, array<T, n>& a) {
  for (auto& u : a) fin >> u;
  return fin;
}
void e551() {
  size_t n, m;
  cin >> n >> m;
  vector<int64_t> a(n);
  cin >> a;
  const size_t chunk = .5 + sqrt(n);
  vector<size_t> id(n);
  for (size_t i = 0; i < n; ++i) id[i] = i / chunk;
  typedef struct {
    int64_t inc;
    size_t head, last;
    map<int64_t, pair<size_t, size_t>> loc;
  } block_t;
  const auto nblk = id.back() + 1;
  vector<block_t> blk(nblk, {0, (size_t)-1, 0, {}});
  for (size_t i = 0; i < n; ++i) {
    auto& b = blk[id[i]];
    b.head = min(b.head, i);
    b.last = i;
  }
  const auto build_block = [&a](block_t& b) {
    for (size_t i = b.head; i < b.last + 1; ++i) {
      auto iter = b.loc.find(a[i]);
      if (iter != end(b.loc))
        iter->second.second = i;
      else
        b.loc.emplace(a[i], make_pair(i, i));
    }
  };
  for (; 0 < m; --m) {
    size_t op;
    cin >> op;
    if (op == 2) {
      int64_t val;
      cin >> val;
      size_t first = -1, last = 0, i;
      for (i = 0; i < nblk; ++i) {
        auto& b = blk[i];
        if (b.loc.empty()) build_block(b);
        const auto iter = b.loc.find(val - b.inc);
        if (iter != end(b.loc)) {
          first = iter->second.first;
          last = iter->second.second;
          break;
        }
      }
      for (size_t j = nblk - 1; i < j; --j) {
        auto& b = blk[j];
        if (b.loc.empty()) build_block(b);
        const auto iter = b.loc.find(val - b.inc);
        if (iter != end(b.loc)) {
          last = iter->second.second;
          break;
        }
      }
      cout << (first != (size_t)-1 ? (int)(last - first) : -1) << '\n';
    } else {
      size_t l, r;
      int64_t inc;
      cin >> l >> r >> inc;
      --l;
      --r;
      for (size_t i = id[l] + 1; i < id[r]; ++i) blk[i].inc += inc;
      auto& b = blk[id[l]];
      b.loc.clear();
      const auto last = 1 + min(r, b.last);
      for (size_t i = l; i < last; ++i) a[i] += inc;
      if (id[l] != id[r]) {
        auto& b = blk[id[r]];
        b.loc.clear();
        for (size_t i = b.head; i < r + 1; ++i) a[i] += inc;
      }
    }
  }
}
int main(const int argc, char* argv[]) {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  ;
  e551();
  return EXIT_SUCCESS;
}
