#include <bits/stdc++.h>
#ifdef ALGO
#include "magica.hpp"
#else
#define DUMP(...)
#define CHECK(...) (__VA_ARGS__)
#endif

namespace {

using LL = long long;
const int INF = 0x3f3f3f3f;

using ValueType = int;

struct Summary {
  LL sum = 0;
  int cnt = 0;
  ValueType vmin = INF;
  ValueType vmax = 0;

  void reset(ValueType value) {
    sum = vmin = vmax = value;
    cnt = 1;
  }

  Summary& append(ValueType value) {
    sum += value;
    ++cnt;
    vmin = std::min(vmin, value);
    vmax = std::max(vmax, value);
    return *this;
  }

  Summary& apply(ValueType added) {
    if (cnt != 0 && added) {
      sum += LL(cnt) * added;
      vmin += added;
      vmax += added;
    }
    return *this;
  }
};

Summary& operator+=(Summary& lhs, const Summary& rhs) {
  lhs.sum += rhs.sum;
  lhs.cnt += rhs.cnt;
  lhs.vmin = std::min(lhs.vmin, rhs.vmin);
  lhs.vmax = std::max(lhs.vmax, rhs.vmax);
  return lhs;
}

Summary operator+(Summary lhs, const Summary& rhs) {
  lhs += rhs;
  return lhs;
}

inline int get_highest_bit(unsigned x) {
  return 31 - __builtin_clz(x);
}

struct CompressedTrie {
  CompressedTrie* ch[2] = {};
  unsigned bits : 27, height : 5;

  Summary summary;
  ValueType lazy_tag = 0;

  void apply(ValueType tag) {
    summary.apply(tag);
    lazy_tag += tag;
  }

  void down() {
    if (lazy_tag == 0) return;
    if (ch[0]) ch[0]->apply(lazy_tag);
    if (ch[1]) ch[1]->apply(lazy_tag);
    lazy_tag = 0;
  }
};

template<typename T>
class MemoryPool {
 public:
  T* allocate() {
    if (__builtin_expect(pool_.empty(), false)) {
      T* arr = new T[kReAllocSize];
      for (int i = 0; i < kReAllocSize; ++i) {
        pool_.emplace_back(arr + i);
      }
    }

    T* ret = pool_.back(); pool_.pop_back();
    return new(ret) T{};
  }

  void free(T* ptr) {
    pool_.emplace_back(ptr);
  }

 private:
  static constexpr int kReAllocSize = 1024;

  std::vector<T*> pool_;
};

MemoryPool<CompressedTrie> pool;

void insert(CompressedTrie*& trie, unsigned bits, ValueType value) {
  if (trie == nullptr) {
    trie = pool.allocate();
    trie->bits = bits;
    trie->height = 0;
    trie->summary.reset(value);
  } else if ((trie->bits ^ bits) >> trie->height) {
    int new_height = get_highest_bit(trie->bits ^ bits) + 1;
    CompressedTrie* new_trie = pool.allocate();
    new_trie->bits = trie->bits;
    new_trie->height = new_height;
    new_trie->ch[trie->bits >> (new_height - 1) & 1] = trie;
    trie = new_trie;
    insert(trie->ch[bits >> (new_height - 1) & 1], bits, value);
    // trie->summary = trie->ch[0]->summary + trie->ch[1]->summary;
    trie->summary.sum = trie->ch[0]->summary.sum + trie->ch[1]->summary.sum;
    trie->summary.cnt = trie->ch[0]->summary.cnt + trie->ch[1]->summary.cnt;
    trie->summary.vmin = std::min(trie->ch[0]->summary.vmin, trie->ch[1]->summary.vmin);
    trie->summary.vmax = std::max(trie->ch[0]->summary.vmax, trie->ch[1]->summary.vmax);
  } else if (trie->height == 0) {
    trie->summary.append(value);
  } else {
    trie->down();
    insert(trie->ch[bits >> (trie->height - 1) & 1], bits, value);
    // trie->summary = trie->ch[0]->summary + trie->ch[1]->summary;
    trie->summary.sum = trie->ch[0]->summary.sum + trie->ch[1]->summary.sum;
    trie->summary.cnt = trie->ch[0]->summary.cnt + trie->ch[1]->summary.cnt;
    trie->summary.vmin = std::min(trie->ch[0]->summary.vmin, trie->ch[1]->summary.vmin);
    trie->summary.vmax = std::max(trie->ch[0]->summary.vmax, trie->ch[1]->summary.vmax);
  }
}

template<typename OnPopOut>
void subtract(CompressedTrie*& trie, int L, int R, ValueType delta, ValueType lower_bound, OnPopOut&& on_pop_out) {
  if (trie == nullptr) {
    return;
  }
  if (trie->summary.vmax + delta <= 0) {
    return;
  }
  int l = trie->bits >> trie->height << trie->height;
  int r = l + (1 << trie->height) - 1;
  if (r < L || R < l) {
    return;
  }
  if (L <= l && r <= R && trie->summary.vmin + delta >= lower_bound) {
    trie->apply(delta);
  } else if (trie->height == 0) {
    on_pop_out(trie->bits, trie->summary.vmin + delta);
    pool.free(trie);
    trie = nullptr;
  } else {
    trie->down();
    subtract(trie->ch[0], L, R, delta, lower_bound, std::forward<OnPopOut>(on_pop_out));
    subtract(trie->ch[1], L, R, delta, lower_bound, std::forward<OnPopOut>(on_pop_out));
    if (trie->ch[0] != nullptr && trie->ch[1] != nullptr) {
      // trie->summary = trie->ch[0]->summary + trie->ch[1]->summary;
      trie->summary.sum = trie->ch[0]->summary.sum + trie->ch[1]->summary.sum;
      trie->summary.cnt = trie->ch[0]->summary.cnt + trie->ch[1]->summary.cnt;
      trie->summary.vmin = std::min(trie->ch[0]->summary.vmin, trie->ch[1]->summary.vmin);
      trie->summary.vmax = std::max(trie->ch[0]->summary.vmax, trie->ch[1]->summary.vmax);
    } else if (trie->ch[0] != nullptr || trie->ch[1] != nullptr) {
      CompressedTrie* tmp = trie->ch[trie->ch[0] == nullptr];
      pool.free(trie);
      trie = tmp;
    } else {
      pool.free(trie);
      trie = nullptr;
    }
  }
}

template<typename Handler>
void query(CompressedTrie* trie, int L, int R, Handler&& handler) {
  if (trie == nullptr) {
    return;
  }
  int l = trie->bits >> trie->height << trie->height;
  int r = l + (1 << trie->height) - 1;
  if (r < L || R < l) {
    return;
  }
  if (L <= l && r <= R) {
    handler(trie->summary);
    return;
  }
  trie->down();
  query(trie->ch[0], L, R, std::forward<Handler>(handler));
  query(trie->ch[1], L, R, std::forward<Handler>(handler));
}

struct IO {
  IO(FILE *in = stdin) : in(in) {}

  IO& operator >> (int& x) {
    x = next_int();
    return *this;
  }

  int next_char() {
    if (position == length) {
      position = 0, length = fread(buffer, 1, LENGTH, in);
    }
    if (position == length) {
      eof = true;
      return -1;
    }
    return buffer[position++];
  }

  int next_uint() {
    int c = next_char(), x = 0;
    while (c <= 32) {
      c = next_char();
    }
    for (; '0' <= c && c <= '9'; c = next_char()) {
      x = x * 10 + c - '0';
    }
    return x;
  }

  int next_int() {
    int s = 1, c = next_char(), x = 0;
    while (c <= 32) {
      c = next_char();
    }
    if (c == '-') {
      s = -1, c = next_char();
    }
    for (; '0' <= c && c <= '9'; c = next_char()) {
      x = x * 10 + c - '0';
    }
    return x * s;
  }

  void next_string(char *s) {
    int c = next_char();
    while (c <= 32) {
      c = next_char();
    }
    for (; c > 32; c = next_char()) {
      *s++ = c;
    }
    *s = 0;
  }

private:
  static const int LENGTH = 1 << 16;

  char buffer[LENGTH];
  int position = 0, length = 0;
  bool eof = false;
  FILE *in;
};

struct FastOut {
  static const int BUFSIZE = 4096;

  FastOut& operator << (int64_t x) {
    print(x);
    return *this;
  }

  FastOut& operator << (const char *s) {
    puts(s);
    return *this;
  }

  void putchar(char c) {
    buf[len++] = c;
    if (len == BUFSIZE) {
      fwrite(buf, 1, BUFSIZE, stdout);
      len = 0;
    }
  }

  void puts(const char *s) {
    while (*s) {
      putchar(*(s++));
    }
  }

  void print(int64_t n) {
    static char bufn[32];
    bool negative = false;
    if (n < 0) {
      n = -n;
      negative = true;
    }
    int top = 32;
    while (n >= 10) {
      bufn[--top] = '0' + n % 10;
      n /= 10;
    }
    bufn[--top] = '0' + n;
    if (negative) {
      bufn[--top] = '-';
    }
    for (; top < 32; ++top) {
      putchar(bufn[top]);
    }
  }

  void println(int64_t n) {
    print(n);
    putchar('\n');
  }

  ~FastOut() {
    if (len) {
      fwrite(buf, 1, len, stdout);
    }
    fflush(stdout);
  }

  char buf[BUFSIZE];
  int len = 0;
};

constexpr int B = 8;

inline uint8_t get_block_id(ValueType value) {
  // return (31 ^ __builtin_clz(value)) >> 3;
  // return (value >> 24) ? 3 : (value >> 16) ? 2 : (value >> 8) ? 1 : 0;
  return (value > 16777215.5) + (value > 65535.5) + (value > 255.5);
  // return uint8_t(bool(value / 16777216)) + bool(value / 65536) + bool(value / 256);
  // return uint8_t(bool(value >> 24)) + bool(value >> 16) + bool(value >> 8);
  // return ((value >> 24) > 0) + ((value >> 16) > 0) + ((value >> 8) > 0);
  // return 3 ^ (__builtin_clz(value) >> 3);
  // int b = -1;
  // for (; value; value /= B, ++b);
  // return b;
}

struct Solver {

  template<typename Reader, typename Writer>
  void solve(Reader&& reader, Writer&& writer) {
    int n, m;
    reader >> n >> m;
    std::vector<ValueType> bounds{1};
    while (bounds.back() * 1LL * B < INF) {
      bounds.emplace_back(bounds.back() * B);
    }
    std::vector<CompressedTrie*> tries(bounds.size(), nullptr);
    for (int i = 0; i < n; ++i) {
      int x;
      reader >> x;
      int b = get_block_id(x);
      assert(b >= 0 && b < bounds.size());
      insert(tries[b], i, x);
    }
    int last_ans = 0;
    while (m--) {
      int op, l, r;
      reader >> op >> l >> r;
      l ^= last_ans;
      r ^= last_ans;
      --l;
      --r;
      assert(0 <= l && l < n);
      assert(0 <= r && r < n);
      if (op == 1) {
        int x;
        reader >> x;
        x ^= last_ans;
        assert(1 <= x && x <= 1e9);
        for (int i = 0; i < tries.size(); ++i) {
          subtract(tries[i], l, r, -x, bounds[i], [&tries, &i](unsigned bits, ValueType value) {
            int j = get_block_id(value);
            assert(j >= 0 && j < i);
            insert(tries[j], bits, value);
          });
        }
      } else {
        Summary result{};
        for (CompressedTrie* trie : tries) {
          query(trie, l, r, [&result](const Summary& summary) {
            result += summary;
          });
        }
        writer << result.sum << " " << result.vmin << " " << result.vmax << "\n";
        last_ans = result.sum & ((1 << 20) - 1);
      }
    }
  }
};

}  // namespace

int main() {
  // std::ios::sync_with_stdio(false);
  // std::cin.tie(nullptr);
  // std::istream& reader = std::cin;
  IO reader;
  FastOut writer;

  Solver().solve(reader, writer);
}