diff --git a/SegmentTreeRMQ.java b/SegmentTreeRMQ.java
new file mode 100644
index 0000000..6a4d133
--- /dev/null
+++ b/SegmentTreeRMQ.java
@@ -0,0 +1,481 @@
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.util.List;
+ 
+class SEG {
+	InputStream is;
+	PrintWriter out;
+	String INPUT = "";
+	
+	void solve()
+	{
+		int n = ni();
+		int[] a = na(n);
+		int Q = ni();
+		int[][] qs = new int[Q][];
+		int[] vs = Arrays.copyOf(a, 2*(n+Q));
+		for(int i = 0;i < Q;i++){
+			int t = ni();
+			if(t == 1){
+				qs[i] = new int[]{1, ni()-1, ni()};
+				vs[i+n] = qs[i][2];
+			}else{
+				qs[i] = new int[]{2};
+			}
+		}
+		
+		for(int i = 0;i < n+Q;i++){
+			vs[i+n+Q] = vs[i] + 1;
+		}
+		vs = shrink(vs);
+		for(int i = 0;i < n;i++)a[i] = vs[i];
+		for(int i = 0;i < Q;i++){
+			if(qs[i][0] == 1){
+				qs[i][2] = vs[i+n];
+			}
+		}
+		
+		st = new SegmentTreeRMQ(2*(n+Q));
+		sit = new LST(2*(n+Q)+2);
+		sit.setRange(2*(n+Q)+2);
+		ans = 0;
+		for(int i = 0;i < n;i++){
+			stand(a[i]);
+		}
+		
+		for(int[] q : qs){
+			if(q[0] == 1){
+				sit(a[q[1]]);
+				a[q[1]] = q[2];
+				stand(a[q[1]]);
+			}else{
+				out.println(ans);
+			}
+		}
+	}
+	
+	SegmentTreeRMQ st;
+	LST sit;
+	long ans = 0;
+	
+	void stand(int v)
+	{
+		int prev = sit.prev(v-1);
+		int next = sit.next(v+1);
+		if(sit.get(v)){
+			if(prev+1 <= v-1)ans -= st.min(prev+1, v);
+			if(next-1 >= v+1)ans -= st.min(v+1, next);
+		}else{
+			ans -= st.min(prev+1, next);
+		}
+		
+		sit.unset(v);
+		st.update(v, st.min(v, v+1)+1);
+		
+		prev = sit.prev(v-1);
+		next = sit.next(v+1);
+		ans += st.min(prev+1, next);
+	}
+	
+	void sit(int v)
+	{
+		int prev = sit.prev(v-1);
+		int next = sit.next(v+1);
+		if(sit.get(v)){
+			if(prev+1 <= v-1)ans -= st.min(prev+1, v);
+			if(next-1 >= v+1)ans -= st.min(v+1, next);
+		}else{
+			ans -= st.min(prev+1, next);
+		}
+		
+		int nv = st.min(v, v+1)-1;
+		if(nv == 0)sit.set(v);
+		st.update(v, nv);
+		
+		prev = sit.prev(v-1);
+		next = sit.next(v+1);
+		if(sit.get(v)){
+			if(prev+1 <= v-1)ans += st.min(prev+1, v);
+			if(next-1 >= v+1)ans += st.min(v+1, next);
+		}else{
+			ans += st.min(prev+1, next);
+		}
+	}
+	
+	public static class LST {
+		public long[][] set;
+		public int n;
+//		public int size;
+		
+		public LST(int n) {
+			this.n = n;
+			int d = 1;
+			for(int m = n;m > 1;m>>>=6, d++);
+			
+			set = new long[d][];
+			for(int i = 0, m = n>>>6;i < d;i++, m>>>=6){
+				set[i] = new long[m+1];
+			}
+//			size = 0;
+		}
+		
+		// [0,r)
+		public LST setRange(int r)
+		{
+			for(int i = 0;i < set.length;i++, r=r+63>>>6){
+				for(int j = 0;j < r>>>6;j++){
+					set[i][j] = -1L;
+				}
+				if((r&63) != 0)set[i][r>>>6] |= (1L<<r)-1;
+			}
+			return this;
+		}
+		
+		// [0,r)
+		public LST unsetRange(int r)
+		{
+			if(r >= 0){
+				for(int i = 0;i < set.length;i++, r=r+63>>>6){
+					for(int j = 0;j < r+63>>>6;j++){
+						set[i][j] = 0;
+					}
+					if((r&63) != 0)set[i][r>>>6] &= ~((1L<<r)-1);
+				}
+			}
+			return this;
+		}
+		
+		public LST set(int pos)
+		{
+			if(pos >= 0 && pos < n){
+//				if(!get(pos))size++;
+				for(int i = 0;i < set.length;i++, pos>>>=6){
+					set[i][pos>>>6] |= 1L<<pos;
+				}
+			}
+			return this;
+		}
+		
+		public LST unset(int pos)
+		{
+			if(pos >= 0 && pos < n){
+//				if(get(pos))size--;
+				for(int i = 0;i < set.length && (i == 0 || set[i-1][pos] == 0L);i++, pos>>>=6){
+					set[i][pos>>>6] &= ~(1L<<pos);
+				}
+			}
+			return this;
+		}
+		
+		public boolean get(int pos)
+		{
+			return pos >= 0 && pos < n && set[0][pos>>>6]<<~pos<0;
+		}
+		
+		public LST toggle(int pos)
+		{
+			return get(pos) ? unset(pos) : set(pos);
+		}
+		
+		public int prev(int pos)
+		{
+			for(int i = 0;i < set.length && pos >= 0;i++, pos>>>=6, pos--){
+				int pre = prev(set[i][pos>>>6], pos&63);
+				if(pre != -1){
+					pos = pos>>>6<<6|pre;
+					while(i > 0)pos = pos<<6|63-Long.numberOfLeadingZeros(set[--i][pos]);
+					return pos;
+				}
+			}
+			return -1;
+		}
+		
+		public int next(int pos)
+		{
+			for(int i = 0;i < set.length && pos>>>6 < set[i].length;i++, pos>>>=6, pos++){
+				int nex = next(set[i][pos>>>6], pos&63);
+				if(nex != -1){
+					pos = pos>>>6<<6|nex;
+					while(i > 0)pos = pos<<6|Long.numberOfTrailingZeros(set[--i][pos]);
+					return pos;
+				}
+			}
+			return -1;
+		}
+		
+		private static int prev(long set, int n)
+		{
+			long h = set<<~n;
+			if(h == 0L)return -1;
+			return -Long.numberOfLeadingZeros(h)+n;
+		}
+		
+		private static int next(long set, int n)
+		{
+			long h = set>>>n;
+			if(h == 0L)return -1;
+			return Long.numberOfTrailingZeros(h)+n;
+		}
+		
+		@Override
+		public String toString()
+		{
+			List<Integer> list = new ArrayList<Integer>();
+			for(int pos = next(0);pos != -1;pos = next(pos+1)){
+				list.add(pos);
+			}
+			return list.toString();
+		}
+	}
+ 
+	
+	public static class SegmentTreeRMQ {
+		public int M, H, N;
+		public int[] st;
+		
+		public SegmentTreeRMQ(int n)
+		{
+			N = n;
+			M = Integer.highestOneBit(Math.max(N-1, 1))<<2;
+			H = M>>>1;
+			st = new int[M];
+//			Arrays.fill(st, 0, M, Integer.MAX_VALUE);
+		}
+		
+		public SegmentTreeRMQ(int[] a)
+		{
+			N = a.length;
+			M = Integer.highestOneBit(Math.max(N-1, 1))<<2;
+			H = M>>>1;
+			st = new int[M];
+			for(int i = 0;i < N;i++){
+				st[H+i] = a[i];
+			}
+			Arrays.fill(st, H+N, M, Integer.MAX_VALUE);
+			for(int i = H-1;i >= 1;i--)propagate(i);
+		}
+		
+		public void update(int pos, int x)
+		{
+			st[H+pos] = x;
+			for(int i = (H+pos)>>>1;i >= 1;i >>>= 1)propagate(i);
+		}
+		
+		private void propagate(int i)
+		{
+			st[i] = Math.min(st[2*i], st[2*i+1]);
+		}
+		
+		public int minx(int l, int r){
+			int min = Integer.MAX_VALUE;
+			if(l >= r)return min;
+			while(l != 0){
+				int f = l&-l;
+				if(l+f > r)break;
+				int v = st[(H+l)/f];
+				if(v < min)min = v;
+				l += f;
+			}
+			
+			while(l < r){
+				int f = r&-r;
+				int v = st[(H+r)/f-1];
+				if(v < min)min = v;
+				r -= f;
+			}
+			return min;
+		}
+		
+		public int min(int l, int r){ return l >= r ? 0 : min(l, r, 0, H, 1);}
+		
+		private int min(int l, int r, int cl, int cr, int cur)
+		{
+			if(l <= cl && cr <= r){
+				return st[cur];
+			}else{
+				int mid = cl+cr>>>1;
+				int ret = Integer.MAX_VALUE;
+				if(cl < r && l < mid){
+					ret = Math.min(ret, min(l, r, cl, mid, 2*cur));
+				}
+				if(mid < r && l < cr){
+					ret = Math.min(ret, min(l, r, mid, cr, 2*cur+1));
+				}
+				return ret;
+			}
+		}
+		
+		public int firstle(int l, int v) {
+			int cur = H+l;
+			while(true){
+				if(st[cur] <= v){
+					if(cur < H){
+						cur = 2*cur;
+					}else{
+						return cur-H;
+					}
+				}else{
+					cur++;
+					if((cur&cur-1) == 0)return -1;
+					if((cur&1)==0)cur>>>=1;
+				}
+			}
+		}
+		
+		public int lastle(int l, int v) {
+			int cur = H+l;
+			while(true){
+				if(st[cur] <= v){
+					if(cur < H){
+						cur = 2*cur+1;
+					}else{
+						return cur-H;
+					}
+				}else{
+					if((cur&cur-1) == 0)return -1;
+					cur--;
+					if((cur&1)==1)cur>>>=1;
+				}
+			}
+		}
+	}
+ 
+	
+	public static int[] shrink(int[] a) {
+		int n = a.length;
+		long[] b = new long[n];
+		for (int i = 0; i < n; i++)
+			b[i] = (long) a[i] << 32 | i;
+		Arrays.sort(b);
+		int[] ret = new int[n];
+		int p = 0;
+		for (int i = 0; i < n; i++) {
+			if (i > 0 && (b[i] ^ b[i - 1]) >> 32 != 0)
+				p++;
+			ret[(int) b[i]] = p;
+		}
+		return ret;
+	}
+ 
+	
+	
+	void run() throws Exception
+	{
+		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
+		out = new PrintWriter(System.out);
+		
+		long s = System.currentTimeMillis();
+		solve();
+		out.flush();
+		if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
+	}
+	
+	public static void main(String[] args) throws Exception { 
+	    new SEG().run(); 
+	    
+	}
+	
+	private byte[] inbuf = new byte[1024];
+	public int lenbuf = 0, ptrbuf = 0;
+	
+	private int readByte()
+	{
+		if(lenbuf == -1)throw new InputMismatchException();
+		if(ptrbuf >= lenbuf){
+			ptrbuf = 0;
+			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
+			if(lenbuf <= 0)return -1;
+		}
+		return inbuf[ptrbuf++];
+	}
+	
+	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
+	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
+	
+	private double nd() { return Double.parseDouble(ns()); }
+	private char nc() { return (char)skip(); }
+	
+	private String ns()
+	{
+		int b = skip();
+		StringBuilder sb = new StringBuilder();
+		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
+			sb.appendCodePoint(b);
+			b = readByte();
+		}
+		return sb.toString();
+	}
+	
+	private char[] ns(int n)
+	{
+		char[] buf = new char[n];
+		int b = skip(), p = 0;
+		while(p < n && !(isSpaceChar(b))){
+			buf[p++] = (char)b;
+			b = readByte();
+		}
+		return n == p ? buf : Arrays.copyOf(buf, p);
+	}
+	
+	private char[][] nm(int n, int m)
+	{
+		char[][] map = new char[n][];
+		for(int i = 0;i < n;i++)map[i] = ns(m);
+		return map;
+	}
+	
+	private int[] na(int n)
+	{
+		int[] a = new int[n];
+		for(int i = 0;i < n;i++)a[i] = ni();
+		return a;
+	}
+	
+	private int ni()
+	{
+		int num = 0, b;
+		boolean minus = false;
+		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
+		if(b == '-'){
+			minus = true;
+			b = readByte();
+		}
+		
+		while(true){
+			if(b >= '0' && b <= '9'){
+				num = num * 10 + (b - '0');
+			}else{
+				return minus ? -num : num;
+			}
+			b = readByte();
+		}
+	}
+	
+	private long nl()
+	{
+		long num = 0;
+		int b;
+		boolean minus = false;
+		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
+		if(b == '-'){
+			minus = true;
+			b = readByte();
+		}
+		
+		while(true){
+			if(b >= '0' && b <= '9'){
+				num = num * 10 + (b - '0');
+			}else{
+				return minus ? -num : num;
+			}
+			b = readByte();
+		}
+	}
+	
+	private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
+}
\ No newline at end of file