#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <set>
#include <cstring>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <random>
#include <cstdlib>

#define debug(x) std::cout << #x << " " << (x) << '\n';
#define pb push_back
#define mp std::make_pair
#define remax(a, b) a = std::max((a), (b));
#define remin(a, b) a = std::min((a), (b));

class FenwickTree {
private:
	std::vector<int64_t> data;

public:
	FenwickTree(int32_t n): data(n + 1, 0) {}

	void add(int32_t ind, int64_t v) {
		while(ind < data.size()) {
			data[ind] += v;
			ind += (ind & (-ind));
		}
	}

	int64_t get(int32_t ind) {
		int64_t res = 0;
		while(ind > 0) {
			res += data[ind];
			ind -= (ind & (-ind));
		}
		return res;
	}
};

struct Interval {
	int32_t l, len;
	int64_t val;

	Interval(int32_t _l, int32_t _len, int64_t _val): l(_l), len(_len), val(_val) {}

	bool operator<(const Interval &o) const {
		if(l != o.l) return l < o.l;
		else if(len != o.len) return len < o.len;
		else return val < o.val;
	}
};

void splitIntervals(std::set<Interval> &s, int32_t l, int32_t r) {
	auto it = s.lower_bound(Interval(l + 1, -1, 0));
	if(it != s.begin()) {
		it--;
		if(it->l != l) {
			auto i1 = Interval(it->l, l - it->l, it->val);
			auto i2 = Interval(l, it->len - (l - it->l), it->val);
			s.erase(it);
			s.insert(i1);
			s.insert(i2);
		}
	}

	it = s.lower_bound(Interval(r + 1, -1, 0));
	if(it != s.begin()) {
		it--;
		if(it->l + it->len != r + 1) {
			auto i1 = Interval(it->l, r - it->l + 1, it->val);
			auto i2 = Interval(r + 1, it->len - (r - it->l + 1), it->val);
			s.erase(it);
			s.insert(i1);
			s.insert(i2);
		}
	}
}

int main() {
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int32_t n, q;
	std::cin >> n >> q;

	std::vector<int32_t> a(n);
	for(int32_t i = 0; i < n; i++) {
		std::cin >> a[i];
	}

	std::vector<int64_t> b(n);
	for(int32_t i = 0; i < n; i++) {
		std::cin >> b[i];
		
		if(i != 0) {
			b[i] += b[i - 1];
		}
	}

	auto getIntervalB = [&b](int32_t l, int32_t r) {
		l--; r--;
		return b[r] - (l == 0 ? 0 : b[l - 1]);
	};

	auto check = [](int32_t m, const std::vector<std::pair<int64_t, int64_t>> &x) {
		int64_t middle = x[m].first, res = 0;
		for(int32_t i = 0; i < x.size(); i++) {
			res += abs(x[i].first - middle) * x[i].second;
		}
		return res;
	};

	std::set<Interval> s;
	for(int32_t i = 0; i < n; i++) {
		s.insert(Interval(i + 1, 1, a[i]));
	}

	FenwickTree fenwick(n);

	for(int32_t i = 0; i < q; i++) {
		int32_t type, l, r;
		std::cin >> type >> l >> r;

		if(type == 1) {
			int32_t x;
			std::cin >> x;

			fenwick.add(l, x);
			fenwick.add(r + 1, -x);

			splitIntervals(s, l, r);
		}
		else {
			splitIntervals(s, l, r);

			std::vector<std::pair<int64_t, int64_t>> x;
			auto it = s.lower_bound(Interval(l, -1, 0));
			while(it->l <= r) {
				int64_t prefSum = fenwick.get(it->l);
				fenwick.add(it->l, -prefSum);
				fenwick.add(it->l + it->len, prefSum);

				x.pb({ it->val + prefSum, getIntervalB(it->l, it->l + it->len - 1) });

				auto jt = it;
				it++;

				s.erase(jt);
			}

			std::sort(x.begin(), x.end());

			int32_t low = 0, high = x.size() - 1;
			while(low < high) {
				int32_t mid = (low + high) / 2;

				//std::cout << mid << " " << check(mid, x) << " " << check(mid + 1, x) << '\n';
				if(check(mid, x) <= check(mid + 1, x)) {
					high = mid;	
				}
				else {
					low = mid + 1;
				}
			}

			assert(low == high);
			std::cout << x[low].first << '\n';

			s.insert(Interval(l, r - l + 1, x[low].first));
		}

		/**
		for(auto &x : s) {
			std::cout << " { " << x.l << ", " << x.len << ", " << x.val << " }, ";
		}
		std::cout << '\n';
		*/
	}
}