Untitled

class UserSolution {
	private final static int N = 200000;
	private final static int SUM = 0;
	private final static int MAX = 1;
	private final static int MIN = 2;

	private static int g(int a, int b) {
		return a > b ? a : b;
	}

	private static int l(int a, int b) {
		return a < b ? a : b;
	}

	int[][] st = new int[3][4 * (N+1)];
	int[] d = new int[N + 1];
	int n;

	public void updateST(int id) {
		st[SUM][id] = st[SUM][2 * id] + st[SUM][2 * id + 1];
		st[MAX][id] = g(st[MAX][2 * id], st[MAX][2 * id + 1]);
		st[MIN][id] = l(st[MIN][2 * id], st[MIN][2 * id + 1]);
	}

	public void build(int id, int l, int r) {
		if (l == r) {
			st[SUM][id] = st[MAX][id] = st[MIN][id] = d[l];
		} else {
			int mid = (l + r) / 2;
			build(2 * id, l, mid);
			build(2 * id + 1, mid + 1, r);
			updateST(id);
		}
	}

	public void update(int id, int l, int r, int i) {
		if (l == r) {
			st[SUM][id] = st[MAX][id] = st[MIN][id] = d[l];
		} else {
			int mid = (l + r) / 2;
			if (l <= i && i <= mid) {
				update(2 * id, l, mid, i);
			} else
				update(2 * id + 1, mid + 1, r, i);
			updateST(id);
		}
	}

	public int get(int m, int id, int l, int r, int u, int v) {
		if (u > r || v < l)
			return m == MIN ? N : 0;
		if (u <= l && v >= r)
			return st[m][id];
		int mid = (l + r) / 2;
		int v1 = get(m, 2 * id, l, mid, u, v);
		int v2 = get(m, 2 * id + 1, mid + 1, r, u, v);
		return m == SUM ? v1 + v2 : m == MAX ? g(v1, v2) : l(v1, v2);
	}

	public void init(int N, int mSubscriber[]) {
		n = N;
		for (int i = 0; i < N; i++) {
			d[i + 1] = mSubscriber[i];
		}
		build(1, 1, n);
	}

	public int subscribe(int mId, int mNum) {
		d[mId] += mNum;
		update(1, 1, n, mId);
		return d[mId];
	}

	public int unsubscribe(int mId, int mNum) {
		return subscribe(mId, -mNum);
	}

	public int count(int sId, int eId) {
		return get(SUM, 1, 1, n, sId, eId);
	}

	public int calculate(int sId, int eId) {
		return get(MAX, 1, 1, n, sId, eId) - get(MIN, 1, 1, n, sId, eId);
	}
}