" Vim with all enhancements
source $VIMRUNTIME/vimrc_example.vim
set dir=$TEMP

hi normal ctermfg=0 ctermbg=9
hi constant ctermfg=6
hi statement ctermfg=1
hi keyword ctermfg=1
hi type ctermfg=1
hi preproc ctermfg=6
hi comment ctermfg=2
hi linenr ctermfg=3
hi number ctermfg=10
hi string ctermfg=13
hi character ctermfg=13
hi def link error normal
hi modemsg ctermfg=0
hi errormsg ctermfg=9
hi special ctermfg=10
hi matchparen ctermfg=9 ctermbg=3
hi search ctermbg=NONE

set number
set relativenumber
set autoread
autocmd InsertEnter * :set norelativenumber
autocmd InsertLeave * :set relativenumber
set nobackup
set noundofile
inoremap {<CR> {<CR><CR>}<C-[>"_ci{

set autoindent
set smarttab
set shiftwidth=4
set softtabstop=4
set tabstop=4
set belloff=all
set guicursor=a:block
set guicursor+=a:blinkon0

" Use the internal diff if available.
" Otherwise use the special 'diffexpr' for Windows.
if &diffopt !~# 'internal'
  set diffexpr=MyDiff()
endif
function MyDiff()
  let opt = '-a --binary '
  if &diffopt =~ 'icase' | let opt = opt . '-i ' | endif
  if &diffopt =~ 'iwhite' | let opt = opt . '-b ' | endif
  let arg1 = v:fname_in
  if arg1 =~ ' ' | let arg1 = '"' . arg1 . '"' | endif
  let arg1 = substitute(arg1, '!', '\!', 'g')
  let arg2 = v:fname_new
  if arg2 =~ ' ' | let arg2 = '"' . arg2 . '"' | endif
  let arg2 = substitute(arg2, '!', '\!', 'g')
  let arg3 = v:fname_out
  if arg3 =~ ' ' | let arg3 = '"' . arg3 . '"' | endif
  let arg3 = substitute(arg3, '!', '\!', 'g')
  if $VIMRUNTIME =~ ' '
    if &sh =~ '\<cmd'
      if empty(&shellxquote)
        let l:shxq_sav = ''
        set shellxquote&
      endif
      let cmd = '"' . $VIMRUNTIME . '\diff"'
    else
      let cmd = substitute($VIMRUNTIME, ' ', '" ', '') . '\diff"'
    endif
  else
    let cmd = $VIMRUNTIME . '\diff'
  endif
  let cmd = substitute(cmd, '!', '\!', 'g')
  silent execute '!' . cmd . ' ' . opt . arg1 . ' ' . arg2 . ' > ' . arg3
  if exists('l:shxq_sav')
    let &shellxquote=l:shxq_sav
  endif
endfunction

hi customSymbol ctermfg=3

autocmd FileType cuda,cpp,c syn match customSymbol display "[~!%^&()\-+=\[\]\|{},.<>?:;]" display
autocmd FileType cuda,cpp,c syn match customSymbol display "\([\/*]\)\@<!\/\([\/*]\)\@!" display
autocmd FileType cuda,cpp,c syn match customSymbol display "\(\/\)\@<!\*\(\/\)\@!" display

autocmd FileType cuda,cpp syn clear cppSpecialError
autocmd FileType cuda,cpp syn clear cCommentError
autocmd FileType cuda,cpp syn clear cWrongComTail
autocmd FileType cuda,cpp syn clear cOctalError
autocmd FileType cuda,cpp syn clear cCommentStartError
autocmd FileType cuda,cpp syn clear cParenError
autocmd FileType cuda,cpp syn clear cErrInBracket
autocmd FileType cuda,cpp syn clear cErrInParen
autocmd FileType cuda,cpp syn clear cSpecialError
autocmd FileType cuda,cpp syn clear cBadContinuation

autocmd FileType cuda,cpp syn clear cConstant
autocmd FileType cuda,cpp syn clear cppConstant

hi fillInThisGap ctermfg=5 ctermbg=0
autocmd FileType cuda,cpp syn keyword keyword nullptr __int8 __int16 __int32 __int64 __int128

let cpp_keywords = [
  \ 'string', 'std', 'stringstream',
  \ 'priority_queue', 'vector', 'pair', 'map', 'set', 'multimap',
  \ 'multiset', 'unordered_multimap', 'unordered_multiset', 'unordered_map',
  \ 'unordered_set', 'function', 'tuple', 'numeric_limits', 'deque', 'queue',
  \ 'stack', 'bitset', 'initializer_list', 'complex', 'cin', 'cout', 'cerr',
  \ 'stdin', 'stdout', 'stderr', 'ifstream', 'ofstream', 'endl', 
  \ 'exception', 'clog'
  \]

let pattern1 = join(cpp_keywords, ' ')

autocmd FileType cuda,cpp exec "syn keyword preproc " . pattern1 . ""

set nomore
function! Build()
	let file_ext = expand('%:e')
	if file_ext == 'cpp'
		execute "normal! :!color 09 & cls & g++ -D __CUSTOM_DEFINE__ -o out.exe -std=c++20 % -Wl,--stack,16000000 -Wall -Wextra -Wconversion && (echo BUILD SUCCESS & color 90 & start cmd /k out.exe ^& echo[ ^& pause ^& exit) || (echo[ & echo BUILD FAILED & pause & color 90)\<CR>:redraw\<CR>"
	elseif file_ext == 'cu'
		execute "normal! :!color 09 & cls & nvcc -D __CUSTOM_DEFINE__ -o out.exe % && (echo BUILD SUCCESS & color 90 & start cmd /k out.exe ^& echo[ ^& pause ^& exit) || (echo[ & echo BUILD FAILED & pause & color 90)\<CR>:redraw\<CR>"
	else
		echo "FILE EXTENSION NOT FOUND"
	endif
endfunction
if !filereadable(expand("%"))
	let g:bf1 = []
else
	let g:bf1 = readfile(expand("%"))
endif
if len(g:bf1) > 0
	let g:bf1 = g:bf1[len(g:bf1)-1]
else
	let g:bf1 = ""
endif
if len(g:bf1) > 3
	let g:bf1 = strpart(g:bf1, 3)
else
	let g:bf1 = ""
endif
function! GenerateRandomStuff()
	let g:bf1 = ''
	for i in range(1,37)
		let g:bf1 = g:bf1 . "----------xX||"[rand() % 14]
	endfor
	let g:bf1 = g:bf1 . ">"
endfunction
function! Global(arg)
	let bf = g:bf1
	let brh_id = synIDtrans(hlID("Normal"))
	let ctermfg = synIDattr(brh_id, "fg", "cterm")
	let ctermbg = synIDattr(brh_id, "bg", "cterm")
	let rnd = "____" 
	let strbruh = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890"
	let cf = ''
	for i in range(1,38)
		let cf = cf . strbruh[rand() % len(strbruh)]
	endfor
	for i in range(1,50)
		let rnd = rnd . strbruh[rand() % len(strbruh)]
	endfor
	let rnd = rnd . ";"
	let cmdogheight = &cmdheight . ""
	let oth2 = "Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>"
	let initcmd = "normal! :silent vsp\<CR>:silent q!\<CR>:silent set cmdheight=69420\<CR>a" . rnd . "\<ESC>gg:call search(\"" . rnd . "\")\<CR>AA\<BS>\<ESC>gg:call search(\"" . bf . "\")\<CR>jO\<CR>\<CR>\<ESC>"
	let delcmd = "normal! Aa\<BS>bruh\<BS>\<BS>\<BS>\<BS>" . cf . "\<ESC>ggGggGggGgg:silent call search(\".\")\<CR>ggGggARANDOM :::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>ABEE\<BS>\<BS>\<BS>\<ESC>:silent call search(\"Congratulations! You have found a text that nobody cares about! Finding out this text means that you have no life, and are will take countless hours just to do something so meaningless. Nobody will congratulate you for what you have discovered. Its just another easter egg amongst the thousands awaiting to be discovered. But there's no purpose. So, I guess congratulations to you. Good job for discovering this easter egg.\")\<CR>" . oth2 . "IARE\<BS>\<BS>\<BS>\<ESC>GASLASH\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>gg:silent call search(\"" . bf . "\")\<CR>A\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<ESC>gg:silent call search(\"" . cf . "\")\<CR>A\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h> // " . bf . "\<ESC>gg:silent call search(\"" . rnd . "\")\<CR>54la\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<ESC>zz:set cmdheight=" . cmdogheight . "\<CR>:redraw\<CR>"
	let curpos=getpos('.')
	if a:arg == 'caseless' || a:arg == 'cases'
		call GenerateRandomStuff()
		let bf = g:bf1
		let chars = ["5","8","9","A"]
		let rand_char = chars[rand() % len(chars)]
		let bruh123 = "cin>>t;while(C++!=t)cerr<<d+\"$\"<<C<<\"\\n\","
		if a:arg == "caseless"
			let bruh123 = "C=t;t++,C++;"
		endif
		execute "normal! gg\"_dGi#include<bits/stdc++.h>\<CR>#define int long long\<CR>#ifndef __CUSTOM_DEFINE__\<CR>#define cerr __othrstream__\<CR>#endif\<CR>using namespace std;template<class a,class b=a>using __pair__=pair<a,b>;\<CR>mt19937_64 __rng__([](){system(\"color 0".rand_char."\");ios_base::sync_with_stdio(0);cin.tie(0);return chrono::system_clock::now().time_since_epoch();}().count());\<CR>inline unsigned int __rand__(){return __rng__();}\<CR>stringstream __othcstream__,__othrstream__;inline void flush(){fputs(__othcstream__.str().c_str(),stdout);__othcstream__.str(\"\");fflush(stdout);}void solve();\<CR>signed main(){unsigned int t=1,C=26;string d;while(--C)d+=\"-\";" . bruh123 . "solve();cerr<<d+\"#\\n\";flush();}\<CR>#define pair __pair__\<CR>#define cout __othcstream__\<CR>#define rand __rand__\<CR>\<ESC>kA // " . bf . "\<ESC>ji\<CR>\<CR>void solve()\<CR>{\<CR>(---------- solve(); ----------)\<CR>}\<CR>\<ESC>100o\<ESC>"
		let date = strftime("%Y/%m/%d %H:%M:%S")
		let fname = expand("%:t")
		execute "normal! AFILE NAME : " . fname . ";\<CR>TEMPLATE CREATED AT : " . date . ";\<CR>\<ESC>kI// \<ESC>kI// \<ESC>jjGA// " . bf . "\<ESC>"
		execute "normal! ?(---------- solve(); ----------)\<CR>\"_cc\<C-[>zb"
	elseif a:arg == 'inverse'
		if search("#ifndef __INVERSE__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! A#ifndef __INVERSE__\<CR>#define __INVERSE__\<CR>inline unsigned int inverse(unsigned int num, unsigned int mod=18446744073709551557ULL)\<CR>{\<CR>unsigned int res=1;\<CR>unsigned int pw=mod-2;\<CR>num %= mod;\<CR>while(pw)\<CR>{\<CR>if(pw&1)\<CR>{\<CR>if(mod > UINT32_MAX)\<CR>res = (unsigned int)((unsigned __int128)(res)*num % mod);\<CR>else\<CR>res = (res*num)%mod;\<CR>}\<CR>pw >>= 1;\<CR>if(mod > UINT32_MAX)\<CR>num = (unsigned int)((unsigned __int128)(num)*num % mod);\<CR>else\<CR>num = (num*num)%mod;\<CR>}\<CR>return res;\<CR>}\<CR>#endif"
		execute delcmd
	elseif a:arg=="fibonacci"
		if search("#ifndef __FIBONACCI__")!=0
			call setpos(".", curpos)
			return
		endif
		execute initcmd
		execute "normal! aA\<C-h>A\<BS>#ifndef __FIBONACCI__\<CR>#define __FIBONACCI__\<CR>unordered_map<unsigned int,vector<unsigned int>>__fibonacci_default_mp__;\<CR>inline unsigned int fibonacci(unsigned int idx, unsigned int mod=18446744073709551557ULL)\<CR>{\<CR>vector<unsigned int>&ref = __fibonacci_default_mp__[mod];\<CR>if(ref.size() == 0)\<CR>ref.push_back(0ULL), ref.push_back(1ULL%mod);\<CR>while(ref.size() <= idx)\<CR>if(*ref.rbegin() >= mod-*(++ref.rbegin()))\<CR>ref.push_back(*ref.rbegin()+*(++ref.rbegin())-mod);\<CR>else\<CR>ref.push_back(*ref.rbegin()+*(++ref.rbegin()));\<CR>return *(ref.begin()+idx);\<CR>}\<CR>#endif"
		execute delcmd
	elseif a:arg=='dsu'
		if search("#ifndef __DSU__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! A#ifndef __DSU__\<CR>#define __DSU__\<CR>class dsu\<CR>{\<CR>size_t*vals, sz;\<CR>public:\<ESC><<A\<CR>size_t find(size_t val)\<CR>{\<CR>stack<int>prev;\<CR>while(*(vals+val) != val)\<CR>prev.push(val), val=*(vals+val);\<CR>while(!prev.empty())\<CR>*(vals+prev.top())=val, prev.pop();\<CR>return val;\<CR>}\<CR>void unite(size_t a, size_t b){*(vals+find(a)) = find(b);}\<CR>bool united(size_t a, size_t b){return find(a)==find(b);}\<CR>dsu():vals(nullptr){};\<CR>dsu(size_t n):vals(new size_t[n]),sz(n)\<CR>{\<CR>for(size_t*it=vals, *en=vals+sz; it!=en; ++it)\<CR>*it=it-vals;\<CR>}\<CR>dsu(const dsu&oth):vals(new size_t[oth.sz]),sz(oth.sz){copy(oth.vals, oth.vals+sz, vals);}\<CR>dsu(dsu&&oth):vals(oth.vals),sz(oth.sz){oth.vals=nullptr, oth.sz=0;}\<CR>~dsu(){delete[]vals;}\<CR>void build(size_t n)\<CR>{\<CR>delete[]vals;\<CR>sz=n, vals=new size_t[sz];\<CR>for(size_t*it=vals, *en=vals+sz; it!=en; ++it)\<CR>*it=it-vals;\<CR>}\<CR>void build(const dsu&oth)\<CR>{\<CR>delete[]vals;\<CR>vals = new size_t[oth.sz], sz=oth.sz;\<CR>copy(oth.vals, oth.vals+sz, vals);\<CR>}\<CR>void build(dsu&&oth)\<CR>{\<CR>vals=oth.vals, sz=oth.sz;\<CR>oth.vals=nullptr, oth.sz=0;\<CR>}\<CR>dsu&operator=(const dsu&oth){build(oth);return *this;}\<CR>dsu&operator=(dsu&&oth){build(oth);return *this;}\<CR>size_t size()const{return sz;}\<CR>};\<CR>#endif"
		execute delcmd
	elseif a:arg=='segtree'
		if search("#ifndef __SEGTREE__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! A#ifndef __SEGTREE__\<CR>#define __SEGTREE__\<CR>template<typename type>struct __segtree_default_fn__\<CR>{\<CR>type operator()(const type&a, const type&b)const{return min(a,b);}\<CR>};\<CR>template<typename type>struct __segtree_default_lz__\<CR>{\<CR>type operator()(const type&a, const type&b, size_t t)const{return t?min(a,b):min(a,b);}\<CR>};\<CR>template<typename type, typename func=__segtree_default_fn__<type>, typename lazy=__segtree_default_lz__<type>>class segtree\<CR>{\<CR>struct tree\<CR>{\<CR>tree*a, *b;\<CR>type val, lz;\<CR>bool islazy=false;\<CR>}\<CR>*tr;\<CR>func fn;\<CR>lazy lz;\<CR>size_t sz;\<CR>type runfn(const type&a, const type&b)const{return fn(a,b);}\<CR>type runlz(const type&a, const type&b, size_t t)const{return lz(a,b,t);}\<CR>size_t prev;\<CR>bool isprev = false;\<CR>size_t id;\<CR>template<typename iter>void constructIt(tree*tr, size_t l, size_t r, iter&it)\<CR>{\<CR>if(l==r)\<CR>{\<CR>tr->val = *it;\<CR>advance(it,1);\<CR>return;\<CR>}\<CR>size_t mid = (l+r)>>1;\<CR>constructIt(tr->a=new tree(), l, mid, it);\<CR>constructIt(tr->b=new tree(), mid+1, r, it);\<CR>tr->val = runfn(tr->a->val, tr->b->val);\<CR>}\<CR>void construct(tree*tr, size_t l, size_t r, const type&val)\<CR>{\<CR>if(l==r)\<CR>{\<CR>tr->val = val;\<CR>return;\<CR>}\<CR>size_t mid = (l+r)>>1;\<CR>construct(tr->a=new tree(), l, mid, val);\<CR>construct(tr->b=new tree(), mid+1, r, val);\<CR>tr->val = runfn(tr->a->val, tr->b->val);\<CR>}\<CR>void construct(tree*tr, size_t l, size_t r)\<CR>{\<CR>if(l==r)\<CR>return;\<CR>size_t mid = (l+r)>>1;\<CR>construct(tr->a=new tree(), l, mid);\<CR>construct(tr->b=new tree(), mid+1, r);\<CR>tr->val = runfn(tr->a->val, tr->b->val);\<CR>}\<CR>void destruct(tree*tr, size_t l, size_t r)\<CR>{\<CR>if(l==r)\<CR>{\<CR>delete tr;\<CR>return;\<CR>}\<CR>size_t mid = (l+r)>>1;\<CR>destruct(tr->a, l, mid);\<CR>destruct(tr->b, mid+1, r);\<CR>delete tr;\<CR>}\<CR>void copy(tree*tr, tree*oth, size_t l, size_t r)\<CR>{\<CR>tr->val = oth->val;\<CR>tr->lz = oth->lz;\<CR>tr->islazy = oth->islazy;\<CR>if(l==r)\<CR>return;\<CR>size_t mid = (l+r)>>1;\<CR>copy(tr->a, oth->a, l, mid);\<CR>copy(tr->b, oth->b, mid+1, r);\<CR>}\<CR>void push(tree*tr, size_t sz)\<CR>{\<CR>tr->val = runlz(tr->val, tr->lz, sz);\<CR>if(sz!=1)\<CR>{\<CR>if(tr->a->islazy)\<CR>tr->a->lz = runlz(tr->a->lz, tr->lz, 1);\<CR>else\<CR>tr->a->islazy=true, tr->a->lz=tr->lz;\<CR>if(tr->b->islazy)\<CR>tr->b->lz = runlz(tr->b->lz, tr->lz, 1);\<CR>else\<CR>tr->b->islazy=true, tr->b->lz=tr->lz;\<CR>}\<CR>tr->islazy = false;\<CR>}\<CR>tree*get(tree*tr, size_t l, size_t r, size_t idx)\<CR>{\<CR>if(tr->islazy)\<CR>push(tr, (r-l)+1);\<CR>if(l==r)\<CR>return tr;\<CR>size_t mid = (l+r)>>1;\<CR>if(idx <= mid)\<CR>return get(tr->a, l, mid, idx);\<CR>return get(tr->b, mid+1, r, idx);\<CR>}\<CR>void update(tree*tr, size_t l, size_t r, size_t ul, size_t ur, const type&val)\<CR>{\<CR>if(tr->islazy)\<CR>push(tr, (r-l)+1);\<CR>if(l>ur || r<ul)\<CR>return;\<CR>if(l>=ul && r<=ur)\<CR>{\<CR>tr->lz = val;\<CR>push(tr, (r-l)+1);\<CR>return;\<CR>}\<CR>size_t mid = (l+r)>>1;\<CR>update(tr->a, l, mid, ul, ur, val);\<CR>update(tr->b, mid+1, r, ul, ur, val);\<CR>tr->val = runfn(tr->a->val, tr->b->val);\<CR>}\<CR>void update(tree*tr, size_t l, size_t r)\<CR>{\<CR>if(tr->islazy)\<CR>push(tr, (r-l)+1);\<CR>if(prev<l || prev>r)\<CR>return;\<CR>if(l==r)\<CR>return;\<CR>size_t mid = (l+r)>>1;\<CR>update(tr->a, l, mid);\<CR>update(tr->b, mid+1, r);\<CR>tr->val = runfn(tr->a->val, tr->b->val);\<CR>}\<CR>type query(tree*tr, size_t l, size_t r, size_t ql, size_t qr)\<CR>{\<CR>if(tr->islazy)\<CR>push(tr, (r-l)+1);\<CR>if(l>=ql && r<=qr)\<CR>return tr->val;\<CR>size_t mid = (l+r)>>1;\<CR>if(mid >= ql)\<CR>{\<CR>if(mid < qr)\<CR>return runfn(query(tr->a, l, mid, ql, qr), query(tr->b, mid+1, r, ql, qr));\<CR>return query(tr->a, l, mid, ql, qr);\<CR>}\<CR>return query(tr->b, mid+1, r, ql, qr);\<CR>}\<CR>public:\<ESC><<A\<CR>segtree():fn(func()),lz(lazy()){sz=0;}\<CR>segtree(func fn1, lazy lz1=lazy()):fn(fn1),lz(lz1){sz=0;}\<CR>segtree(const segtree&oth):fn(oth.fn),lz(oth.lz),sz(oth.sz),prev(oth.prev),isprev(oth.isprev)\<CR>{\<CR>if(sz)\<CR>{\<CR>construct(tr=new tree(), 0, sz-1);\<CR>copy(tr, oth.tr, 0, sz-1);\<CR>}\<CR>}\<CR>segtree(segtree&&oth):tr(oth.tr),fn(oth.fn),lz(oth.lz),sz(oth.sz),prev(oth.prev),isprev(oth.isprev){oth.tr=nullptr,oth.sz=0,oth.isprev=false;}\<CR>segtree(size_t n, func fn1=func(), lazy lz1=lazy()):fn(fn1),lz(lz1),sz(n)\<CR>{\<CR>if(sz)\<CR>construct(tr=new tree(), 0, sz-1);\<CR>}\<CR>segtree(size_t n, lazy lz1):segtree(n,func(),lz1){}\<CR>segtree(size_t n, const type&defval, func fn1=func(), lazy lz1=lazy()):fn(fn1),lz(lz1),sz(n)\<CR>{\<CR>if(sz)\<CR>construct(tr=new tree(), 0, sz-1, defval);\<CR>}\<CR>segtree(size_t n, const type&defval, lazy lz1):segtree(n,defval,func(),lz1){}\<CR>template<typename iter>segtree(iter begin, iter end, func fn1=func(), lazy lz1=lazy()):fn(fn1),lz(lz1),sz(distance(begin,end))\<CR>{\<CR>if(sz)\<CR>constructIt(tr=new tree(), 0, sz-1, begin);\<CR>}\<CR>template<typename iter>segtree(iter begin, iter end, lazy lz1):segtree(begin,end,func(),lz1){}\<CR>segtree(initializer_list<type>tmp, func fn1=func(), lazy lz1=lazy()):segtree(tmp.begin(),tmp.end(),fn1,lz1){}\<CR>segtree(initializer_list<type>tmp, lazy lz1):segtree(tmp.begin(),tmp.end(),func(),lz1){}\<CR>~segtree()\<CR>{\<CR>if(sz)\<CR>destruct(tr, 0, sz-1);\<CR>}\<CR>void build(size_t n)\<CR>{\<CR>if(sz)\<CR>destruct(tr, 0, sz-1);\<CR>sz=n;\<CR>isprev=false;\<CR>if(sz)\<CR>construct(tr=new tree(), 0, sz-1);\<CR>}\<CR>void build(const segtree&oth)\<CR>{\<CR>if(sz)\<CR>destruct(tr, 0, sz-1);\<CR>sz=oth.sz;\<CR>isprev = oth.isprev, prev = oth.prev;\<CR>if(sz)\<CR>{\<CR>construct(tr=new tree(), 0, sz-1);\<CR>copy(tr, oth.tr, 0, sz-1);\<CR>}\<CR>}\<CR>void build(segtree&&oth)\<CR>{\<CR>if(sz)\<CR>destruct(tr, 0, sz-1);\<CR>sz=oth.sz;\<CR>isprev = oth.isprev, prev = oth.prev;\<CR>tr = oth.tr;\<CR>oth.tr = nullptr;\<CR>oth.sz = 0;\<CR>oth.isprev = false;\<CR>}\<CR>void build(size_t n, const type&defval)\<CR>{\<CR>if(sz)\<CR>destruct(tr, 0, sz-1);\<CR>sz=n;\<CR>isprev=false;\<CR>if(sz)\<CR>construct(tr=new tree(), 0, sz-1, defval);\<CR>}\<CR>template<typename it>void build(it begin, it end)\<CR>{\<CR>if(sz)\<CR>destruct(tr, 0, sz-1);\<CR>sz=distance(begin,end);\<CR>isprev = false;\<CR>if(sz)\<CR>constructIt(tr=new tree(), 0, sz-1, begin);\<CR>}\<CR>void build(initializer_list<type>tmp){build(tmp.begin(),tmp.end());}\<CR>segtree&operator=(const segtree&oth)\<CR>{\<CR>build(oth);\<CR>return *this;\<CR>}\<CR>segtree&operator=(segtree&&oth)\<CR>{\<CR>build(oth);\<CR>return *this;\<CR>}\<CR>type&operator[](size_t idx)\<CR>{\<CR>if(isprev)\<CR>update(tr, 0, sz-1);\<CR>else\<CR>isprev=true;\<CR>prev = idx;\<CR>return get(tr, 0, sz-1, idx)->val;\<CR>}\<CR>const type&operator[](size_t idx)const\<CR>{\<CR>segtree*cur = const_cast<segtree*>(this);\<CR>if(isprev)\<CR>cur->update(tr, 0, sz-1), cur->isprev=false;\<CR>return cur->get(tr, 0, sz-1, idx)->val;\<CR>}\<CR>void update(size_t idx, const type&val)\<CR>{\<CR>if(isprev)\<CR>update(tr, 0, sz-1), isprev=false;\<CR>update(tr, 0, sz-1, idx, idx, val);\<CR>}\<CR>void update(size_t ul, size_t ur, const type&val)\<CR>{\<CR>if(isprev)\<CR>update(tr, 0, sz-1), isprev = false;\<CR>update(tr, 0, sz-1, ul, ur, val);\<CR>}\<CR>type query(size_t ql, size_t qr)const\<CR>{\<CR>segtree*cur = const_cast<segtree*>(this);\<CR>if(isprev)\<CR>cur->update(tr, 0, sz-1), cur->isprev = false;\<CR>return cur->query(tr, 0, sz-1, ql, qr);\<CR>}\<CR>size_t size()const{return sz;}\<CR>};\<CR>#endif"
		execute delcmd
	elseif a:arg=="prime"
		if search("#ifndef __PRIME__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! A#ifndef __PRIME__\<CR>#define __PRIME__\<CR>class prime\<CR>{\<CR>static vector<unsigned int>primes;\<CR>static bool*sieve;\<CR>static size_t sz;\<CR>static void push()\<CR>{\<CR>if(sz==0)\<CR>{\<CR>sz=1;\<CR>sieve = new bool[1]();\<CR>*sieve = true;\<CR>primes = {3};\<CR>return;\<CR>}\<CR>delete[]sieve;\<CR>sieve = new bool[sz<<1]();\<CR>bool*ptrBeg = sieve;\<CR>sz<<=1;\<CR>bool*ptrEnd = sieve+(sz/3+1);\<CR>bool*ptrTrueEnd = sieve+sz;\<CR>size_t prmNum=0;\<CR>while(ptrBeg != ptrEnd)\<CR>{\<CR>if(!(*ptrBeg))\<CR>{\<CR>size_t dist = ptrBeg-sieve+1;\<CR>size_t prm = (dist<<1)|1;\<CR>if(prmNum == primes.size())\<CR>primes.push_back(prm);\<CR>++prmNum;\<CR>for(bool*ptr = ptrBeg+prm; ptr<ptrTrueEnd; ptr+=prm)\<CR>*ptr = true;\<CR>}\<CR>++ptrBeg;\<CR>}\<CR>}\<CR>public:\<ESC><<A\<CR>static unsigned int get(size_t num)\<CR>{\<CR>if(num==0)\<CR>return 2ULL;\<CR>while(primes.size() < num)\<CR>push();\<CR>return primes[num-1];\<CR>}\<CR>static bool isprime(unsigned int num)\<CR>{\<CR>if(num < 2)\<CR>return false;\<CR>if(num < 4)\<CR>return true;\<CR>if(!(num&1))\<CR>return false;\<CR>num = (num>>1)-1;\<CR>while(sz <= num)\<CR>push();\<CR>return !(*(sieve+num));\<CR>}\<CR>static vector<pair<unsigned int,unsigned int>>factor(unsigned int num)\<CR>{\<CR>if(num <= 1)\<CR>return vector<pair<unsigned int,unsigned int>>();\<CR>vector<pair<unsigned int,unsigned int>>res;\<CR>size_t idx=0;\<CR>unsigned int prd=2;\<CR>while(prd<=num/prd && !isprime(num) && num!=1)\<CR>{\<CR>prd = get(idx);\<CR>++idx;\<CR>if(num%prd == 0)\<CR>{\<CR>unsigned int count=0;\<CR>while(num%prd == 0)\<CR>{\<CR>num /= prd;\<CR>++count;\<CR>}\<CR>res.push_back(pair<unsigned int,unsigned int>(prd,count));\<CR>}\<CR>}\<CR>if(num != 1)\<CR>res.push_back(pair<unsigned int,unsigned int>(num,1));\<CR>return res;\<CR>}\<CR>};\<CR>size_t prime::sz=0;\<CR>bool*prime::sieve=nullptr;\<CR>vector<unsigned int>prime::primes;\<CR>#endif"
		execute delcmd
	elseif a:arg=="factor"
		if search("#ifndef __FACTOR__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! A#ifndef __FACTOR__\<CR>#define __FACTOR__\<CR>vector<unsigned int>factor(unsigned int num)\<CR>{\<CR>if(num==0)\<CR>return vector<unsigned int>();\<CR>vector<unsigned int>res;\<CR>stack<unsigned int>aft;\<CR>unsigned int n=1;\<CR>while(n <= (num-1)/n)\<CR>{\<CR>if(num%n == 0){\<CR>res.push_back(n);\<CR>aft.push(num/n);\<ESC>kkA\<C-h>\<ESC>jA\<C-h>,\<ESC>jA\<CR>++n;\<CR>}\<CR>if(num%n == 0)\<CR>res.push_back(n);\<CR>while(!aft.empty()){\<CR>res.push_back(aft.top());\<CR>aft.pop();\<ESC>kkA\<C-h>\<ESC>jA\<C-h>,\<ESC>jA\<CR>return res;\<CR>}\<CR>#endif"
		execute delcmd
	elseif a:arg=="graph"
		if search("#ifndef __GRAPH__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! A#ifndef __GRAPH__\<CR>#define __GRAPH__\<CR>template<typename value=unsigned char, typename patht=void>class graph\<CR>{\<CR>struct custType{};\<CR>typedef typename conditional<is_same<patht,void>::value,custType,patht>::type pathtype;\<CR>value*vals;\<CR>vector<size_t>*path;\<CR>vector<pair<size_t,pathtype>>*pathNoVoid;\<CR>size_t sz;\<CR>vector<size_t>&pathsVoid(size_t idx){return *(path+idx);}\<CR>vector<pair<size_t,pathtype>>&pathsNoVoid(size_t idx){return *(pathNoVoid+idx);}\<CR>const vector<size_t>&pathsVoid(size_t idx)const{return *(path+idx);}\<CR>const vector<pair<size_t,pathtype>>&pathsNoVoid(size_t idx)const{return *(pathNoVoid+idx);}\<CR>public:\<ESC><<A\<CR>graph():vals(nullptr),path(nullptr),pathNoVoid(nullptr){}\<CR>graph(const graph&oth):sz(oth.sz)\<CR>{\<CR>vals = new value[sz]();\<CR>if(is_same<pathtype,custType>::value)\<CR>{\<CR>path = new vector<size_t>[sz]();\<CR>pathNoVoid = nullptr;\<CR>copy(oth.path, oth.path+sz, path);\<CR>}\<CR>else\<CR>{\<CR>pathNoVoid = new vector<pair<size_t,pathtype>>[sz]();\<CR>path = nullptr;\<CR>copy(oth.pathNoVoid, oth.pathNoVoid+sz, pathNoVoid);\<CR>}\<CR>copy(oth.vals, oth.vals+sz, vals);\<CR>}\<CR>graph(graph&&oth):vals(oth.vals),path(oth.path),pathNoVoid(oth.pathNoVoid),sz(oth.sz)\<CR>{\<CR>oth.vals = nullptr;\<CR>oth.path = nullptr;\<CR>oth.pathNoVoid = nullptr;\<CR>oth.sz = 0;\<CR>}\<CR>graph(size_t n):sz(n)\<CR>{\<CR>vals = new value[n]();\<CR>if(is_same<pathtype,custType>::value)\<CR>path = new vector<size_t>[n](), pathNoVoid=nullptr;\<CR>else\<CR>pathNoVoid = new vector<pair<size_t,pathtype>>[n](), path=nullptr;\<CR>}\<CR>~graph()\<CR>{\<CR>delete[]vals;\<CR>delete[]path;\<CR>delete[]pathNoVoid;\<CR>}\<CR>void build(size_t n)\<CR>{\<CR>delete[]vals;\<CR>delete[]path;\<CR>delete[]pathNoVoid;\<CR>vals = new value[n]();\<CR>if(is_same<pathtype,custType>::value)\<CR>path = new vector<size_t>[n](), pathNoVoid=nullptr;\<CR>else\<CR>pathNoVoid = new vector<pair<size_t,pathtype>>[n](), path=nullptr;\<CR>sz = n;\<CR>}\<CR>graph&operator=(const graph&oth)\<CR>{\<CR>sz = oth.sz;\<CR>delete[]vals;\<CR>delete[]path;\<CR>delete[]pathNoVoid;\<CR>vals = new value[sz]();\<CR>if(is_same<pathtype,custType>::value)\<CR>{\<CR>path = new vector<size_t>[sz]();\<CR>pathNoVoid = nullptr;\<CR>copy(oth.path, oth.path+sz, path);\<CR>}\<CR>else\<CR>{\<CR>pathNoVoid = new vector<pair<size_t,pathtype>>[sz]();\<CR>path = nullptr;\<CR>copy(oth.pathNoVoid, oth.pathNoVoid+sz, pathNoVoid);\<CR>}\<CR>copy(oth.vals, oth.vals+sz, vals);\<CR>return*this;\<CR>}\<CR>graph&operator=(graph&&oth)\<CR>{\<CR>sz = oth.sz;\<CR>delete[]vals;\<CR>delete[]path;\<CR>delete[]pathNoVoid;\<CR>vals = oth.vals;\<CR>path = oth.path;\<CR>pathNoVoid = oth.pathNoVoid;\<CR>oth.vals = nullptr;\<CR>oth.path = nullptr;\<CR>oth.pathNoVoid = nullptr;\<CR>return*this;\<CR>}\<CR>void build(const graph&oth){(*this)=oth;}\<CR>void build(graph&&oth){(*this)=oth;}\<CR>size_t size()const{return sz;}\<CR>value&operator[](size_t idx){return *(vals+idx);}\<CR>const value&operator[](size_t idx)const{return *(vals+idx);}\<CR>typename conditional<is_same<pathtype,custType>::value,vector<size_t>,vector<pair<size_t,pathtype>>>::type&paths(size_t idx)\<CR>{\<CR>if constexpr(is_same<pathtype,custType>::value)\<CR>return pathsVoid(idx);\<CR>else\<CR>return pathsNoVoid(idx);\<CR>}\<CR>const typename conditional<is_same<pathtype,custType>::value,vector<size_t>,vector<pair<size_t,pathtype>>>::type&paths(size_t idx)const\<CR>{\<CR>if constexpr(is_same<pathtype,custType>::value)\<CR>return pathsVoid(idx);\<CR>else\<CR>return pathsNoVoid(idx);\<CR>}\<CR>void connect(size_t a, size_t b, bool isbidirectional=true)\<CR>{\<CR>if constexpr(is_same<pathtype,custType>::value)\<CR>{\<CR>path[a].push_back(b);\<CR>if(isbidirectional)\<CR>path[b].push_back(a);\<CR>}\<CR>else\<CR>{\<CR>pathNoVoid[a].push_back(pair<size_t,pathtype>(b,pathtype()));\<CR>if(isbidirectional)\<CR>pathNoVoid[b].push_back(pair<size_t,pathtype>(a,pathtype()));\<CR>}\<CR>}\<CR>void connect(size_t a, size_t b, bool isbidirectional, const typename conditional<is_same<pathtype,custType>::value,char,pathtype>::type&val)\<CR>{\<CR>pathNoVoid[a].push_back(pair<size_t,pathtype>(b,val));\<CR>if(isbidirectional)\<CR>pathNoVoid[b].push_back(pair<size_t,pathtype>(a,val));\<CR>}\<CR>};\<CR>#endif"
	
		execute delcmd
	elseif a:arg=="tree"
		if search("#ifndef __GRAPH__")==0
			execute "normal! :C graph\<CR>"
		else
			call setpos('.', curpos)
		endif
		if search("#ifndef __TREE__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! a#ifndef __TREE__\<CR>#define __TREE__\<CR>template<typename value=unsigned char, typename patht=void>class tree\<CR>{\<CR>struct custType{};\<CR>typedef typename conditional<is_same<patht,void>::value,custType,patht>::type pathtype;\<CR>static const constexpr bool isVoid = is_same<pathtype,custType>::value;\<CR>struct node\<CR>{\<CR>size_t*parent;\<CR>pair<size_t,pathtype>*parentNoVoid;\<CR>vector<pair<size_t,pathtype>>*childrenNoVoid;\<CR>vector<size_t>*children;\<CR>value val;\<CR>size_t height, size;\<CR>node()\<CR>{\<CR>height=size=0;\<CR>if(isVoid)\<CR>children = new vector<size_t>(), parent=new size_t(), childrenNoVoid=nullptr, parentNoVoid=nullptr;\<CR>else\<CR>childrenNoVoid = new vector<pair<size_t,pathtype>>(), parentNoVoid=new pair<size_t,pathtype>(), children=nullptr, parent=nullptr;\<CR>}\<CR>node&operator=(const node&oth)\<CR>{\<CR>if(isVoid)\<CR>{\<CR>delete parent;\<CR>delete children;\<CR>children = new vector<size_t>(*oth.children);\<CR>parent = new size_t(*oth.parent);\<CR>}\<CR>else\<CR>{\<CR>delete childrenNoVoid;\<CR>delete parentNoVoid;\<CR>childrenNoVoid = new vector<pair<size_t,pathtype>>(*oth.childrenNoVoid);\<CR>parentNoVoid = new pair<size_t,pathtype>(*oth.parentNoVoid);\<CR>}\<CR>val = oth.val;\<CR>height = oth.height;\<CR>size = oth.size;\<CR>return*this;\<CR>}\<CR>~node()\<CR>{\<CR>if(isVoid)\<CR>delete children,delete parent;\<CR>else\<CR>delete childrenNoVoid,delete parentNoVoid;\<CR>}\<CR>};\<CR>node*nodes;\<CR>size_t sz, root1;\<CR>void change1(bool*vsted, size_t val, size_t tfirst)\<CR>{\<CR>if(*(vsted+val))\<CR>(nodes+tfirst)->size += (nodes+val)->size;\<CR>}\<CR>void change1(bool*vsted, const pair<size_t,pathtype>&val, size_t tfirst)\<CR>{\<CR>if(*(vsted+val.first))\<CR>(nodes+tfirst)->size += (nodes+val.first)->size;\<CR>}\<CR>void change2(bool*vsted, size_t val, size_t tfirst, stack<pair<size_t,bool>>&st)\<CR>{\<CR>if(!*(vsted+val))\<CR>{\<CR>(nodes+tfirst)->children->push_back(val);\<CR>*(vsted+val) = true;\<CR>st.push(pair<size_t,bool>(val,false));\<CR>(nodes+val)->height = (nodes+tfirst)->height+1;\<CR>*((nodes+val)->parent) = tfirst;\<CR>}\<CR>}\<CR>void change2(bool*vsted, const pair<size_t,pathtype>&val, size_t tfirst, stack<pair<size_t,bool>>&st)\<CR>{\<CR>if(!*(vsted+val.first))\<CR>{\<CR>(nodes+tfirst)->childrenNoVoid->push_back(val);\<CR>*(vsted+val.first) = true;\<CR>st.push(pair<size_t,bool>(val.first,false));\<CR>(nodes+val.first)->height = (nodes+tfirst)->height+1;\<CR>*((nodes+val.first)->parentNoVoid) = pair<size_t,pathtype>(tfirst,val.second);\<CR>}\<CR>}\<CR>void dfs(const graph<value,patht>&oth)\<CR>{\<CR>stack<pair<size_t,bool>>st;\<CR>st.push(pair<size_t,bool>(root1,false));\<CR>bool*vsted = new bool[sz]();\<CR>*(vsted+root1) = true;\<CR>while(!st.empty())\<CR>{\<CR>pair<size_t,bool>&t = st.top();\<CR>if(t.second)\<CR>{\<CR>(nodes+t.first)->size = 1;\<CR>for(decltype(oth.paths(t.first).begin()) it=oth.paths(t.first).begin(), en=oth.paths(t.first).end(); it!=en; ++it)\<CR>change1(vsted,*it,t.first);\<CR>st.pop();\<CR>}\<CR>else\<CR>{\<CR>t.second = true;\<CR>for(decltype(oth.paths(t.first).begin()) it=oth.paths(t.first).begin(), en=oth.paths(t.first).end(); it!=en; ++it)\<CR>change2(vsted,*it,t.first,st);\<CR>}\<CR>}\<CR>delete[]vsted;\<CR>for(size_t i=0; i<sz; ++i)\<CR>(nodes+i)->val = oth[i];\<CR>}\<CR>const vector<size_t>&childrenVoid(size_t idx)const{return *((nodes+idx)->children);}\<CR>const vector<pair<size_t,pathtype>>&childrenNoVoid(size_t idx)const{return *((nodes+idx)->childrenNoVoid);}\<CR>const size_t&parentVoid(size_t idx)const{return *((nodes+idx)->parent);};\<CR>const pair<size_t,pathtype>&parentNoVoid(size_t idx)const{return *((nodes+idx)->parentNoVoid);};\<CR>public:\<ESC><<A\<CR>tree():nodes(nullptr){}\<CR>tree(const tree&oth):sz(oth.sz),root1(oth.root1)\<CR>{\<CR>nodes = new node[sz]();\<CR>copy(oth.nodes, oth.nodes+sz, nodes);\<CR>}\<CR>tree(tree&&oth):sz(oth.sz),root1(oth.root1),nodes(oth.nodes){oth.nodes=nullptr,oth.sz=oth.root1=0;}\<CR>tree(const graph<value,patht>&oth, size_t root2):sz(oth.size()),root1(root2){nodes = new node[sz](), dfs(oth);}\<CR>~tree(){delete[]nodes;}\<CR>void build(const tree&oth)\<CR>{\<CR>sz = oth.sz;\<CR>root1 = oth.root1;\<CR>delete[]nodes;\<CR>nodes = new node[sz]();\<CR>copy(oth.nodes, oth.nodes+sz, nodes);\<CR>}\<CR>void build(tree&&oth)\<CR>{\<CR>sz = oth.sz;\<CR>root1 = oth.root1;\<CR>delete[]nodes;\<CR>nodes = oth.nodes;\<CR>oth.nodes = nullptr;\<CR>oth.sz=oth.root1=0;\<CR>}\<CR>void build(const graph<value,patht>&oth, size_t root1)\<CR>{\<CR>sz = oth.size();\<CR>delete[]nodes;\<CR>nodes = new node[sz]();\<CR>this->root1 = root1;\<CR>dfs(oth);\<CR>}\<CR>tree&operator=(const tree&oth)\<CR>{\<CR>build(oth);\<CR>return*this;\<CR>}\<CR>tree&operator=(tree&&oth)\<CR>{\<CR>build(oth);\<CR>return*this;\<CR>}\<CR>size_t size()const{return sz;}\<CR>value&operator[](size_t idx){return (nodes+idx)->val;}\<CR>const value&operator[](size_t idx)const{return (nodes+idx)->val;}\<CR>const typename conditional<isVoid,vector<size_t>,vector<pair<size_t,pathtype>>>::type&children(size_t idx)const\<CR>{\<CR>if constexpr(isVoid)\<CR>return childrenVoid(idx);\<CR>else\<CR>return childrenNoVoid(idx);\<CR>}\<CR>const typename conditional<isVoid,size_t,pair<size_t,pathtype>>::type&parent(size_t idx)const\<CR>{\<CR>if constexpr(isVoid)\<CR>return parentVoid(idx);\<CR>else\<CR>return parentNoVoid(idx);\<CR>}\<CR>size_t root()const{return root1;}\<CR>size_t height(size_t idx)const{return (nodes+idx)->height;}\<CR>size_t subtree(size_t idx)const{return (nodes+idx)->size;}\<CR>};\<CR>#endif"
		execute delcmd
	elseif a:arg=="binary_lifting"
		if search("#ifndef __TREE__")==0
			execute "normal! :C tree\<CR>"
		else
			call setpos('.', curpos)
		endif
		if search("#ifndef __BINARY_LIFTING__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! a#ifndef __BINARY_LIFTING__\<CR>#define __BINARY_LIFTING__\<CR>class binary_lifting\<CR>{\<CR>struct node\<CR>{\<CR>vector<size_t>parents;\<CR>size_t height;\<CR>};\<CR>node*nodes;\<CR>size_t sz, root1;\<CR>void change(stack<size_t>&st, size_t val){st.push(val);}\<CR>template<typename pathtype>void change(stack<size_t>&st, const pair<size_t,pathtype>&val){st.push(val.first);}\<CR>size_t getParent(size_t val){return val;}\<CR>template<typename pathtype>size_t getParent(const pair<size_t,pathtype>&val){return val.first;}\<CR>template<typename value, typename pathtype>void startBuild(const tree<value,pathtype>&tr)\<CR>{\<CR>stack<size_t>st;\<CR>st.push(root1);\<CR>while(!st.empty())\<CR>{\<CR>size_t tp = st.top();\<CR>st.pop();\<CR>(nodes+tp)->height = tr.height(tp);\<CR>for(decltype(tr.children(tp).begin()) it=tr.children(tp).begin(), en=tr.children(tp).end(); it!=en; ++it)\<CR>change(st,*it);\<CR>size_t nxt = tp;\<CR>if(nxt != root1)\<CR>{\<CR>nxt = getParent(tr.parent(tp));\<CR>(nodes+tp)->parents.push_back(nxt);\<CR>size_t idx = 0;\<CR>while((nodes+nxt)->parents.size() > idx)\<CR>{\<CR>nxt = (nodes+nxt)->parents[idx];\<CR>++idx;\<CR>(nodes+tp)->parents.push_back(nxt);\<CR>}\<CR>}\<CR>}\<CR>}\<CR>public:\<ESC><<A\<CR>binary_lifting():nodes(nullptr),sz(0),root1(0){}\<CR>binary_lifting(const binary_lifting&oth):nodes(new node[oth.sz]()),sz(oth.sz),root1(oth.root1){copy(oth.nodes, oth.nodes+sz, nodes);}\<CR>binary_lifting(binary_lifting&&oth):nodes(oth.nodes),sz(oth.sz),root1(oth.root1){oth.nodes=nullptr, oth.sz=oth.root1=0;}\<CR>template<typename value, typename pathtype>binary_lifting(const tree<value,pathtype>&tr):nodes(new node[tr.size()]()),sz(tr.size()),root1(tr.root()){startBuild(tr);}\<CR>~binary_lifting(){delete[]nodes;}\<CR>void build(const binary_lifting&oth)\<CR>{\<CR>sz = oth.sz;\<CR>root1 = oth.root1;\<CR>delete[]nodes;\<CR>nodes = new node[sz]();\<CR>copy(oth.nodes, oth.nodes+sz, nodes);\<CR>}\<CR>void build(binary_lifting&&oth)\<CR>{\<CR>sz = oth.sz;\<CR>root1 = oth.root1;\<CR>delete[]nodes;\<CR>nodes = oth.nodes;\<CR>oth.nodes = nullptr;\<CR>oth.sz=oth.root1 = 0;\<CR>}\<CR>binary_lifting&operator=(const binary_lifting&oth)\<CR>{\<CR>build(oth);\<CR>return *this;\<CR>}\<CR>binary_lifting&operator=(binary_lifting&&oth)\<CR>{\<CR>build(oth);\<CR>return *this;\<CR>}\<CR>template<typename value, typename pathtype>void build(const tree<value,pathtype>&tr)\<CR>{\<CR>delete[]nodes;\<CR>sz = tr.size();\<CR>nodes = new node[sz]();\<CR>startBuild(tr);\<CR>}\<CR>size_t ancestor(size_t a, size_t k)const\<CR>{\<CR>size_t idx=0;\<CR>while(k)\<CR>{\<CR>if((nodes+a)->parents.size() <= idx)\<CR>return root1;\<CR>if(k&1)\<CR>a = (nodes+a)->parents[idx];\<CR>++idx;\<CR>k >>= 1;\<CR>}\<CR>return a;\<CR>}\<CR>template<typename fn>size_t binary_search(size_t a, const fn&func=fn())const\<CR>{\<CR>size_t res=a;\<CR>while(func(res) && res!=root1)\<CR>{\<CR>size_t idx=1;\<CR>node*ptr = nodes+res;\<CR>while(ptr->parents.size() > idx)\<CR>{\<CR>if(!func(ptr->parents[idx]))\<CR>break;\<CR>++idx;\<CR>}\<CR>res = ptr->parents[--idx];\<CR>}\<CR>return res;\<CR>}\<CR>size_t lca(size_t a, size_t b)const\<CR>{\<CR>if(b==root1 || a==root1)\<CR>return root1;\<CR>if((nodes+a)->height>(nodes+b)->height)\<CR>a = ancestor(a, (nodes+a)->height - (nodes+b)->height);\<CR>else if((nodes+b)->height>(nodes+a)->height)\<CR>b = ancestor(b, (nodes+b)->height - (nodes+a)->height);\<CR>size_t idx = 0;\<CR>do\<CR>{\<CR>idx = 0;\<CR>while((nodes+a)->parents[idx] != (nodes+b)->parents[idx])\<CR>{\<CR>++idx;\<CR>if((nodes+a)->parents.size() <= idx)\<CR>break;\<CR>}\<CR>if(idx != 0)\<CR>a = (nodes+a)->parents[--idx], b = (nodes+b)->parents[idx];\<CR>}\<CR>while(idx != 0);\<CR>if(a == b)\<CR>return a;\<CR>return *((nodes+a)->parents.begin());\<CR>}\<CR>size_t size()const{return sz;}\<CR>size_t root()const{return root1;}\<CR>};\<CR>#endif\<ESC>"
		execute delcmd
	elseif a:arg=="factorial"
		if search("#ifndef __FACTORIAL__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! A#ifndef __FACTORIAL__\<CR>#define __FACTORIAL__\<CR>unordered_map<unsigned int,vector<unsigned int>>__factorial_default_mp__;\<CR>inline unsigned int factorial(unsigned int idx, unsigned int mod=18446744073709551557ULL)\<CR>{\<CR>vector<unsigned int>&ref = __factorial_default_mp__[mod];\<CR>if(ref.size() == 0)\<CR>ref.push_back(1ULL%mod);\<CR>if(mod > UINT32_MAX)\<CR>while(ref.size() <= idx)\<CR>ref.push_back((unsigned int)(((unsigned __int128)(ref.back())*ref.size()) % mod));\<CR>else\<CR>while(ref.size() <= idx)\<CR>ref.push_back(ref.back()*ref.size() % mod);\<CR>return ref[idx];\<CR>}\<CR>#endif"
		execute delcmd
	elseif a:arg=="ncr"
		if search("#ifndef __MINT__")==0
			execute "normal! :C mint\<CR>"
			let curpos=getpos('.')
		else
			call setpos('.', curpos)
		endif
		if search("#ifndef __FACTORIAL__")==0
			execute "normal! :C factorial\<CR>"
		else
			call setpos('.', curpos)
		endif
		if search("#ifndef __NCR__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		execute "normal! a#ifndef __NCR__\<CR>#define __NCR__\<CR>inline unsigned int ncr(unsigned int n, unsigned int r, unsigned int mod=18446744073709551557ULL)\<CR>{\<CR>if(n<r)\<CR>return 0ULL;\<CR>if(n==r)\<CR>return 1ULL%mod;\<CR>if(mod > UINT32_MAX)\<CR>return (unsigned int)(((unsigned __int128)factorial(n,mod)) * inverse(factorial(r,mod), mod) % mod * inverse(factorial(n-r,mod), mod) % mod);\<CR>return factorial(n,mod) * inverse(factorial(r,mod), mod) % mod * inverse(factorial(n-r,mod), mod) % mod;\<CR>}\<CR>inline unsigned int npr(unsigned int n, unsigned int r, unsigned int mod=18446744073709551557ULL)\<CR>{\<CR>if(r==0)\<CR>return 1ULL%mod;\<CR>if(r==1)\<CR>return n%mod;\<CR>if(mod > UINT32_MAX)\<CR>return (unsigned int)(((unsigned __int128)factorial(n,mod)) * inverse(factorial(n-r,mod), mod) % mod);\<CR>return factorial(n,mod) * inverse(factorial(n-r,mod), mod) % mod;\<CR>}\<CR>#endif"
		execute delcmd
	elseif a:arg=="space"
		if search("#ifndef __SPACE__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __SPACE__\<CR>#define __SPACE__\<CR>template<const size_t k, typename val=unsigned char, typename axisType=int, typename comp=less<axisType>>class space\<CR>{\<CR>public:\<ESC><<A\<CR>class less\<CR>{\<CR>const size_t*order;\<CR>comp cmp1;\<CR>public:\<ESC><<A\<CR>less(const size_t*o,comp cmp):order(o),cmp1(cmp){}\<CR>bool operator()(const axisType*a, const axisType*b)const\<CR>{\<CR>for(const size_t*it=order, *en=order+k; it!=en; ++it)\<CR>{\<CR>bool eq = cmp1(*(a+*it), *(b+*it));\<CR>if(eq != cmp1(*(b+*it), *(a+*it)))\<CR>return eq;\<CR>}\<CR>return false;\<CR>}\<CR>};\<CR>private:\<ESC><<A\<CR>comp cmp;\<CR>struct hsh\<CR>{\<CR>size_t operator()(const size_t*ptr)const\<CR>{\<CR>size_t res=0;\<CR>__i__=0;\<CR>for(const size_t*en=ptr+k; ptr!=en; ++ptr)\<CR>res = res*__p__()+(*ptr);\<CR>return res;\<CR>}\<CR>};\<CR>struct iseq\<CR>{\<CR>bool operator()(const size_t*a, const size_t*b)const\<CR>{\<CR>for(const size_t*ea=a+k; ea!=a; ++a,++b)\<CR>if(*a != *b)\<CR>return false;\<CR>return true;\<CR>}\<CR>};\<CR>vector<pair<unsigned char,pair<axisType*,val>>>order;\<CR>axisType*updated=nullptr;\<CR>unordered_map<size_t*,pair<size_t,map<axisType*,val,less>>,hsh,iseq>pts;\<CR>pair<size_t,set<axisType,comp>>*axises;\<CR>pair<size_t,map<axisType,size_t,comp>>*axisesSzes;\<CR>size_t*defptr, sz;\<CR>void deleteNoDestroy()\<CR>{\<CR>for(decltype(pts.begin()) it=pts.begin(), en=pts.end(); it!=en; ++it)\<CR>delete[]it->first;\<CR>if(updated != nullptr)\<CR>delete[]updated;\<CR>for(decltype(order.begin()) it=order.begin(), en=order.end(); it!=en; ++it)\<CR>delete[]it->second.first;\<CR>for(pair<size_t,set<axisType,comp>>*it=axises, *en=axises+k; it!=en; ++it)\<CR>it->~pair<size_t,set<axisType,comp>>();\<CR>for(pair<size_t,map<axisType,size_t,comp>>*it=axisesSzes, *en=axisesSzes+k; it!=en; ++it)\<CR>it->~pair<size_t,map<axisType,size_t,comp>>();\<CR>free(axises);\<CR>free(axisesSzes);\<CR>}\<CR>public:\<ESC><<A\<CR>space(comp c=comp()):cmp(c),sz(0)\<CR>{\<CR>axises = static_cast<pair<size_t,set<axisType,comp>>*>(malloc(k*sizeof(pair<size_t,set<axisType,comp>>)));\<CR>for(pair<size_t,set<axisType,comp>>*it=axises, *en=axises+k; it!=en; ++it)\<CR>new(it)pair<size_t,set<axisType,comp>>(0,set<axisType,comp>(cmp));\<CR>axisesSzes = static_cast<pair<size_t,map<axisType,size_t,comp>>*>(malloc(k*sizeof(pair<size_t,map<axisType,size_t,comp>>)));\<CR>for(pair<size_t,map<axisType,size_t,comp>>*it=axisesSzes, *en=axisesSzes+k; it!=en; ++it)\<CR>new(it)pair<size_t,map<axisType,size_t,comp>>(0,map<axisType,size_t,comp>(cmp));\<CR>defptr = new size_t[k];\<CR>for(size_t*it=defptr, *en=defptr+k, idx=0; it!=en; ++it,++idx)\<CR>*it = idx;\<CR>pts.insert(pair<size_t*,pair<size_t,map<axisType*,val,less>>>(defptr,pair<size_t,map<axisType*,val,less>>(0,map<axisType*,val,less>(less(defptr,cmp)))));\<CR>}\<CR>space(const space&oth):cmp(oth.cmp),sz(oth.sz)\<CR>{\<CR>defptr = new size_t[k];\<CR>for(size_t*it=defptr, *en=defptr+k, idx=0; it!=en; ++it,++idx)\<CR>*it = idx;\<CR>axises = static_cast<pair<size_t,set<axisType,comp>>*>(malloc(k*sizeof(pair<size_t,set<axisType,comp>>)));\<CR>for(pair<size_t,set<axisType,comp>>*it=axises, *en=axises+k; it!=en; ++it)\<CR>new(it)pair<size_t,set<axisType,comp>>(0,set<axisType,comp>(cmp));\<CR>axisesSzes = (pair<size_t,map<axisType,size_t,comp>>*)malloc(k*sizeof(pair<size_t,map<axisType,size_t,comp>>));\<CR>for(pair<size_t,map<axisType,size_t,comp>>*it=axisesSzes, *en=axisesSzes+k; it!=en; ++it)\<CR>new(it)pair<size_t,map<axisType,size_t,comp>>(0,map<axisType,size_t,comp>(cmp));\<CR>decltype(oth.pts.at(defptr)) found = oth.pts.at(defptr);\<CR>map<axisType*,val,less>&ref = pts.insert(pair<size_t*,pair<size_t,map<axisType*,val,less>>>(defptr,pair<size_t,map<axisType*,val,less>>(found.second.size(),map<axisType*,val,less>(less(defptr,cmp))))).first->second.second;\<CR>for(decltype(found.second.begin()) it=found.second.begin(), en=found.second.end(); it!=en; ++it)\<CR>{\<CR>axisType*nw = new axisType[k];\<CR>for(axisType*ft=nw, *gt=it->first, *fn=nw+k; ft!=fn; ++ft,++gt)\<CR>*ft=*gt;\<CR>pair<axisType*,val>tmp = pair<axisType*,val>(nw,it->second);\<CR>ref.insert(tmp);\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(1,tmp));\<CR>}\<CR>}\<CR>space(space&&oth):cmp(oth.cmp),order(move(oth.order)),pts(move(oth.pts)),sz(oth.sz),axises(oth.axises),axisesSzes(oth.axisesSzes),defptr(oth.defptr)\<CR>{\<CR>oth.sz = 0;\<CR>oth.axises = static_cast<pair<size_t,set<axisType,comp>>*>(malloc(k*sizeof(pair<size_t,set<axisType,comp>>)));\<CR>for(pair<size_t,set<axisType,comp>>*it=axises, *en=axises+k; it!=en; ++it)\<CR>new(it)pair<size_t,set<axisType,comp>>(0,set<axisType,comp>(cmp));\<CR>axisesSzes = (pair<size_t,map<axisType,size_t,comp>>*)malloc(k*sizeof(pair<size_t,map<axisType,size_t,comp>>));\<CR>for(pair<size_t,map<axisType,size_t,comp>>*it=axisesSzes, *en=axisesSzes+k; it!=en; ++it)\<CR>new(it)pair<size_t,map<axisType,size_t,comp>>(0,map<axisType,size_t,comp>(cmp));\<CR>for(size_t*it=oth.defptr, *en=oth.defptr+k, idx=0; it!=en; ++it,++idx)\<CR>*it = idx;\<CR>oth.pts.insert(pair<size_t*,pair<size_t,map<axisType*,val,less>>>(oth.defptr,pair<size_t,map<axisType*,val,less>>(0,map<axisType*,val,less>(less(oth.defptr,cmp)))));\<CR>}\<CR>~space(){deleteNoDestroy();}\<CR>void build(const space&oth)\<CR>{\<CR>deleteNoDestroy();\<CR>order.clear();\<CR>pts.clear();\<CR>updated = nullptr;\<CR>sz = oth.sz;\<CR>defptr = new size_t[k];\<CR>for(size_t*it=defptr, *en=defptr+k, idx=0; it!=en; ++it,++idx)\<CR>*it = idx;\<CR>axises = static_cast<pair<size_t,set<axisType,comp>>*>(malloc(k*sizeof(pair<size_t,set<axisType,comp>>)));\<CR>for(pair<size_t,set<axisType,comp>>*it=axises, *en=axises+k; it!=en; ++it)\<CR>new(it)pair<size_t,set<axisType,comp>>(0,set<axisType,comp>(cmp));\<CR>axisesSzes = (pair<size_t,map<axisType,size_t,comp>>*)malloc(k*sizeof(pair<size_t,map<axisType,size_t,comp>>));\<CR>for(pair<size_t,map<axisType,size_t,comp>>*it=axisesSzes, *en=axisesSzes+k; it!=en; ++it)\<CR>new(it)pair<size_t,map<axisType,size_t,comp>>(0,map<axisType,size_t,comp>(cmp));\<CR>decltype(oth.pts.at(defptr)) found = oth.pts.at(defptr);\<CR>map<axisType*,val,less>&ref = pts.insert(pair<size_t*,pair<size_t,map<axisType*,val,less>>>(defptr,pair<size_t,map<axisType*,val,less>>(found.second.size(),map<axisType*,val,less>(less(defptr,cmp))))).first->second.second;\<CR>for(decltype(found.second.begin()) it=found.second.begin(), en=found.second.end(); it!=en; ++it)\<CR>{\<CR>axisType*nw = new axisType[k];\<CR>for(axisType*ft=nw, *gt=it->first, *fn=nw+k; ft!=fn; ++ft,++gt)\<CR>*ft=*gt;\<CR>pair<axisType*,val>tmp = pair<axisType*,val>(nw,it->second);\<CR>ref.insert(tmp);\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(1,tmp));\<CR>}\<CR>}\<CR>void build(space&&oth)\<CR>{\<CR>deleteNoDestroy();\<CR>order = move(oth.order);\<CR>pts = move(oth.pts);\<CR>sz = oth.sz;\<CR>updated = nullptr;\<CR>axises = oth.axises;\<CR>axisesSzes = oth.axisesSzes;\<CR>defptr = oth.defptr;\<CR>oth.sz = 0;\<CR>oth.axises = static_cast<pair<size_t,set<axisType,comp>>*>(malloc(k*sizeof(pair<size_t,set<axisType,comp>>)));\<CR>for(pair<size_t,set<axisType,comp>>*it=axises, *en=axises+k; it!=en; ++it)\<CR>new(it)pair<size_t,set<axisType,comp>>(0,set<axisType,comp>(cmp));\<CR>axisesSzes = (pair<size_t,map<axisType,size_t,comp>>*)malloc(k*sizeof(pair<size_t,map<axisType,size_t,comp>>));\<CR>for(pair<size_t,map<axisType,size_t,comp>>*it=axisesSzes, *en=axisesSzes+k; it!=en; ++it)\<CR>new(it)pair<size_t,map<axisType,size_t,comp>>(0,map<axisType,size_t,comp>(cmp));\<CR>for(size_t*it=oth.defptr, *en=oth.defptr+k, idx=0; it!=en; ++it,++idx)\<CR>*it = idx;\<CR>oth.pts.insert(pair<size_t*,pair<size_t,map<axisType*,val,less>>>(oth.defptr,pair<size_t,map<axisType*,val,less>>(0,map<axisType*,val,less>(less(oth.defptr,cmp)))));\<CR>}\<CR>void clear()\<CR>{\<CR>deleteNoDestroy();\<CR>order.clear();\<CR>pts.clear();\<CR>updated = nullptr;\<CR>sz = 0;\<CR>axises = static_cast<pair<size_t,set<axisType,comp>>*>(malloc(k*sizeof(pair<size_t,set<axisType,comp>>)));\<CR>for(pair<size_t,set<axisType,comp>>*it=axises, *en=axises+k; it!=en; ++it)\<CR>new(it)pair<size_t,set<axisType,comp>>(0,set<axisType,comp>(cmp));\<CR>axisesSzes = static_cast<pair<size_t,map<axisType,size_t,comp>>*>(malloc(k*sizeof(pair<size_t,map<axisType,size_t,comp>>)));\<CR>for(pair<size_t,map<axisType,size_t,comp>>*it=axisesSzes, *en=axisesSzes+k; it!=en; ++it)\<CR>new(it)pair<size_t,map<axisType,size_t,comp>>(0,map<axisType,size_t,comp>(cmp));\<CR>defptr = new size_t[k];\<CR>for(size_t*it=defptr, *en=defptr+k, idx=0; it!=en; ++it,++idx)\<CR>*it = idx;\<CR>pts.insert(pair<size_t*,pair<size_t,map<axisType*,val,less>>>(defptr,pair<size_t,map<axisType*,val,less>>(0,map<axisType*,val,less>(less(defptr,cmp)))));\<CR>}\<CR>space&operator=(const space&oth){build(oth);return*this;}\<CR>space&operator=(space&&oth){build(oth);return*this;}\<CR>void insert(initializer_list<axisType>lst,const val&v=val()){insert(lst.begin(),v);}\<CR>template<typename iter>void insert(iter begin, const val&v=val())\<CR>{\<CR>pair<size_t,map<axisType*,val,less>>&ref = pts.at(defptr);\<CR>if(updated != nullptr)\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(2,pair<axisType*,val>(updated,ref.second.at(updated)))), updated=nullptr;\<CR>axisType*tmp = new axisType[k];\<CR>for(axisType*en=tmp+k; tmp!=en; ++tmp,++begin)\<CR>*tmp = *begin;\<CR>tmp-=k;\<CR>bool res = ref.second.insert(pair<axisType*,val>(tmp,v)).second;\<CR>if(res)\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(1,pair<axisType*,val>(tmp,v))), ++sz;\<CR>else\<CR>delete[]tmp;\<CR>++ref.first;\<CR>}\<CR>void erase(initializer_list<axisType>lst){erase(lst.begin());}\<CR>template<typename iter>void erase(iter begin)\<CR>{\<CR>pair<size_t,map<axisType*,val,less>>&ref = pts.at(defptr);\<CR>if(updated != nullptr)\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(2,pair<axisType*,val>(updated,ref.second.at(updated)))), updated=nullptr;\<CR>axisType*tmp = new axisType[k];\<CR>for(axisType*en=tmp+k; tmp!=en; ++tmp,++begin)\<CR>*tmp = *begin;\<CR>tmp-=k;\<CR>if(ref.second.erase(tmp))\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(0,pair<axisType*,val>(tmp,val()))), --sz;\<CR>else\<CR>delete[]tmp;\<CR>++ref.first;\<CR>}\<CR>const map<axisType*,val,less>&points(initializer_list<size_t>lst){return points(lst.begin());}\<CR>template<typename iter>const map<axisType*,val,less>&points(iter begin)\<CR>{\<CR>if(updated != nullptr)\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(2,pair<axisType*,val>(updated,pts.at(defptr).second.at(updated)))), updated=nullptr;\<CR>size_t*tmp = new size_t[k];\<CR>pair<size_t,map<axisType*,val,less>>*ref;\<CR>for(size_t*en=tmp+k; tmp!=en; ++tmp,++begin)\<CR>*tmp = *begin;\<CR>tmp -= k;\<CR>decltype(pts.find(tmp)) tmpit=pts.find(tmp);\<CR>if(tmpit == pts.end())\<CR>ref = &(pts.insert(pair<size_t*,pair<size_t,map<axisType*,val,less>>>(tmp,pair<size_t,map<axisType*,val,less>>(0,map<axisType*,val,less>(less(tmp,cmp))))).first->second);\<CR>else\<CR>{\<CR>ref = &(tmpit->second);\<CR>delete[]tmp;\<CR>}\<CR>for(decltype(order.begin()+ref->first) it=order.begin()+ref->first, en=order.end(); it!=en; ++it)\<CR>if(it->first == 1)\<CR>ref->second.insert(it->second);\<CR>else if(it->first == 0)\<CR>ref->second.erase(it->second.first);\<CR>else\<CR>ref->second.at(it->second.first) = it->second.second;\<CR>ref->first = order.size();\<CR>return ref->second;\<CR>}\<CR>const set<axisType,comp>&axis(size_t idx)\<CR>{\<CR>const map<axisType*,val,less>&ref = pts.at(defptr).second;\<CR>if(updated != nullptr)\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(2,pair<axisType*,val>(updated,ref.at(updated)))), updated=nullptr;\<CR>pair<size_t,set<axisType,comp>>*found = axises+idx;\<CR>pair<size_t,map<axisType,size_t,comp>>*foundSz = axisesSzes+idx;\<CR>if(found->first <= order.size())\<CR>for(decltype(order.begin()+found->first) it=order.begin()+found->first, en=order.end(); it!=en; ++it)\<CR>{\<CR>if(it->first == 1)\<CR>{\<CR>if(found->second.find(*(it->second.first+idx)) == found->second.end())\<CR>found->second.insert(*(it->second.first+idx)), foundSz->second.insert(pair<axisType,size_t>(*(it->second.first+idx),0));\<CR>else\<CR>++foundSz->second.find(*(it->second.first+idx))->second;\<CR>}\<CR>else if(it->first == 0)\<CR>{\<CR>decltype(foundSz->second.find(*(it->second.first+idx))) pos = foundSz->second.find(*(it->second.first+idx));\<CR>if(pos->second)\<CR>--pos->second;\<CR>else\<CR>found->second.erase(*(it->second.first+idx)), foundSz->second.erase(pos);\<CR>}\<CR>}\<CR>found->first = order.size();\<CR>return found->second;\<CR>}\<CR>val&operator[](initializer_list<axisType>lst){return operator[](lst.begin());}\<CR>template<typename iter>val&operator[](iter begin)\<CR>{\<CR>map<axisType*,val,less>&ref = pts.at(defptr).second;\<CR>if(updated != nullptr)\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(2,pair<axisType*,val>(updated,ref.at(updated))));\<CR>axisType*tmp = new axisType[k];\<CR>for(axisType*en=tmp+k; tmp!=en; ++tmp,++begin)\<CR>*tmp = *begin;\<CR>tmp-=k;\<CR>decltype(ref.find(tmp)) found;\<CR>updated = tmp;\<CR>if((found=ref.find(tmp)) != ref.end())\<CR>return found->second;\<CR>++sz;\<CR>axisType*tmp2 = new axisType[k];\<CR>for(axisType*en=tmp2+k; tmp2!=en; ++tmp2,++tmp)\<CR>*tmp2 = *tmp;\<CR>tmp2 -= k;\<CR>order.push_back(pair<unsigned char,pair<axisType*,val>>(1,pair<axisType*,val>(tmp2,val())));\<CR>val&res = ref.insert(pair<axisType*,val>(tmp2,val())).first->second;\<CR>return res;\<CR>}\<CR>size_t size()const{return sz;}\<CR>};\<CR>#endif"
		exec delcmd
	elseif a:arg=="array_hash"
		if search("#ifndef __ARRAY_HASH__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __ARRAY_HASH__\<CR>#define __ARRAY_HASH__\<CR>class array_hash\<CR>{\<CR>size_t sz;\<CR>unsigned int*hsh,*pws;\<CR>const constexpr static unsigned __int128 mod = static_cast<unsigned __int128>(18446744073709551557ULL);\<CR>static time_t tminms;\<CR>void initialize(size_t fact)\<CR>{\<CR>size_t*order = new size_t[fact];\<CR>for(size_t*it=order, *en=order+fact; it!=en; ++it)\<CR>*it = it-order;\<CR>mt19937 rng(static_cast<unsigned long>(tminms));\<CR>shuffle(order,order+fact,rng);\<CR>unsigned int*ptr=hsh, *ptrPw=pws;\<CR>unsigned int*en=hsh+sz;\<CR>*pws = 1;\<CR>while(ptr != en)\<CR>{\<CR>*ptr = static_cast<unsigned int>(static_cast<unsigned __int128>((*(order+static_cast<size_t>(*ptr))))%mod);\<CR>if(ptr != hsh)\<CR>{\<CR>unsigned int*prev=ptr, *prev2=ptrPw;\<CR>*ptrPw = static_cast<unsigned int>((static_cast<unsigned __int128>(fact)*static_cast<unsigned __int128>(*(--prev2)))%mod);\<CR>*ptr = static_cast<unsigned int>((static_cast<unsigned __int128>(*ptr)*static_cast<unsigned __int128>(*ptrPw)%mod+static_cast<unsigned __int128>(*(--prev)))%mod);\<CR>}\<CR>++ptr, ++ptrPw;\<CR>}\<CR>delete[]order;\<CR>}\<CR>public:\<ESC><<A\<CR>array_hash():sz(0),hsh(nullptr),pws(nullptr){}\<CR>template<typename val, typename comp=less<val>>array_hash(initializer_list<val>lst, const comp&cmp=comp()):array_hash(lst.begin(),lst.end(),cmp){}\<CR>template<typename it, typename comp=less<typename iterator_traits<it>::value_type>>array_hash(it begin, it end, const comp&cmp=comp()):sz(distance(begin,end)),hsh(new unsigned int[sz]),pws(new unsigned int[sz])\<CR>{\<CR>if(sz == 0)\<CR>return;\<CR>typename iterator_traits<it>::value_type*tmp = new typename iterator_traits<it>::value_type[sz];\<CR>copy(begin, end, tmp);\<CR>typename iterator_traits<it>::value_type*en = tmp+sz;\<CR>sort(tmp, en, cmp);\<CR>en = unique(tmp, en);\<CR>for(decltype(hsh)iter=hsh, end=hsh+sz; iter!=end; ++iter,++begin)\<CR>*iter = static_cast<unsigned int>(distance(tmp,lower_bound(tmp, en, *begin, cmp)));\<CR>initialize(distance(tmp,en));\<CR>delete[]tmp;\<CR>}\<CR>array_hash(const array_hash&oth):sz(oth.sz),hsh(new unsigned int[sz]),pws(new unsigned int[sz]){copy(oth.hsh, oth.hsh+sz, hsh),copy(oth.pws, oth.pws+sz, pws);}\<CR>array_hash(array_hash&&oth):sz(oth.sz),hsh(oth.hsh),pws(oth.pws){oth.sz=0,oth.hsh=nullptr,oth.pws=nullptr;}\<CR>~array_hash(){delete[]hsh;delete[]pws;}\<CR>template<typename val, typename comp=less<val>>void build(initializer_list<val>lst, const comp&cmp=comp()){build(lst.begin(),lst.end().cmp);}\<CR>template<typename it, typename comp=less<typename iterator_traits<it>::value_type>>void build(it begin, it end, const comp&cmp=comp())\<CR>{\<CR>sz=distance(begin,end);\<CR>delete[]hsh;\<CR>delete[]pws;\<CR>pws = new unsigned int[sz];\<CR>hsh = new unsigned int[sz];\<CR>if(sz == 0)\<CR>return;\<CR>typename iterator_traits<it>::value_type*tmp = new typename iterator_traits<it>::value_type[sz];\<CR>copy(begin, end, tmp);\<CR>typename iterator_traits<it>::value_type*en = tmp+sz;\<CR>sort(tmp, en, cmp);\<CR>en = unique(tmp, en);\<CR>for(decltype(hsh)iter=hsh, end=hsh+sz; iter!=end; ++iter,++begin)\<CR>*iter = static_cast<unsigned int>(distance(tmp,lower_bound(tmp, en, *begin, cmp)));\<CR>initialize(distance(tmp,en));\<CR>delete[]tmp;\<CR>}\<CR>void build(const array_hash&oth){delete[]hsh;delete[]pws;sz=oth.sz;hsh=new unsigned int[sz];pws=new unsigned int[sz];copy(oth.hsh,oth.hsh+sz,hsh);copy(oth.pws,oth.pws+sz,pws);}\<CR>void build(array_hash&&oth){delete[]hsh;delete[]pws;sz=oth.sz;hsh=oth.hsh;pws=oth.pws;oth.sz=0;oth.hsh=nullptr;oth.pws=nullptr;}\<CR>array_hash&operator=(const array_hash&oth){build(oth);return*this;}\<CR>array_hash&operator=(array_hash&&oth){build(oth);return*this;}\<CR>unsigned int hash(size_t l, size_t r)const\<CR>{\<CR>unsigned int res = l?*(hsh+r)<*(hsh+(l-1))?static_cast<unsigned int>(mod)-*(hsh+(l-1))+*(hsh+r):*(hsh+r)-*(hsh+(l-1)):*(hsh+r);\<CR>return static_cast<unsigned int>((static_cast<unsigned __int128>(res) * static_cast<unsigned __int128>(*(pws+(sz-l-1)))) % mod);\<CR>}\<CR>unsigned int max_hash()const{return 18446744073709551556ULL;}\<CR>unsigned int size()const{return sz;}\<CR>};\<CR>time_t array_hash::tminms = chrono::system_clock::now().time_since_epoch().count();\<CR>#endif"
		exec delcmd
	elseif a:arg=="mint"
		if search("#ifndef __INVERSE__")==0
			execute "normal! :C inverse\<CR>"
		else
			call setpos('.', curpos)
		endif
		if search("#ifndef __MINT__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __MINT__\<CR>#define __MINT__\<CR>template<const unsigned int mod=18446744073709551557ULL>class mint\<CR>{\<CR>unsigned int val;\<CR>public:\<ESC><<A\<CR>mint():val(0){}\<CR>mint(const mint&oth):val(oth.val){}\<CR>template<typename ty>mint(const ty&oth):val(static_cast<unsigned int>(oth)%mod){}\<CR>template<typename ty>operator ty()const{return static_cast<ty>(val);}\<CR>bool operator<(const mint&oth){return val<oth.val;}\<CR>template<typename ty>bool operator<(const ty&oth){return static_cast<ty>(val)<oth;}\<CR>bool operator>(const mint&oth){return val>oth.val;}\<CR>template<typename ty>bool operator>(const ty&oth){return static_cast<ty>(val)>oth;}\<CR>bool operator==(const mint&oth){return val==oth.val;}\<CR>template<typename ty>bool operator==(const ty&oth){return static_cast<ty>(val)==oth;}\<CR>bool operator!=(const mint&oth){return val!=oth.val;}\<CR>template<typename ty>bool operator!=(const ty&oth){return static_cast<ty>(val)!=oth;}\<CR>bool operator<=(const mint&oth){return val<=oth.val;}\<CR>template<typename ty>bool operator<=(const ty&oth){return static_cast<ty>(val)<=oth;}\<CR>bool operator>=(const mint&oth){return val>=oth.val;}\<CR>template<typename ty>bool operator>=(const ty&oth){return static_cast<ty>(val)>=oth;}\<CR>mint&operator=(const mint&oth){val=oth.val;return*this;}\<CR>template<typename ty>mint&operator=(const ty&oth){val=static_cast<unsigned int>(oth),val%=mod;return*this;}\<CR>mint&operator+=(const mint&oth){val=val<mod-oth.val?val+oth.val:val+oth.val-mod;return*this;}\<CR>template<typename ty>mint&operator+=(const ty&oth){return(*this)+=mint(oth);}\<CR>mint&operator-=(const mint&oth){val=val<oth.val?mod-oth.val+val:val-oth.val;return*this;}\<CR>template<typename ty>mint&operator-=(const ty&oth){return(*this)-=mint(oth);}\<CR>mint&operator*=(const mint&oth){val=mod>UINT32_MAX?static_cast<unsigned int>(static_cast<unsigned __int128>(val)*static_cast<unsigned __int128>(oth.val)%static_cast<unsigned __int128>(mod)):val*oth.val%mod;return*this;}\<CR>template<typename ty>mint&operator*=(const ty&oth){return(*this)*=mint(oth);}\<CR>mint&operator/=(const mint&oth){val/=oth.val;return*this;}\<CR>template<typename ty>mint&operator/=(const ty&oth){return(*this)/=mint(oth);}\<CR>mint&operator%=(const mint&oth){val%=oth.val;return*this;}\<CR>template<typename ty>mint&operator%=(const ty&oth){return(*this)%=mint(oth);}\<CR>mint operator+(const mint&oth)const{return mint(*this)+=oth;}\<CR>template<typename ty>mint operator+(const ty&oth)const{return mint(*this)+=oth;}\<CR>mint operator-(const mint&oth)const{return mint(*this)-=oth;}\<CR>template<typename ty>mint operator-(const ty&oth)const{return mint(*this)-=oth;}\<CR>mint operator*(const mint&oth)const{return mint(*this)*=oth;}\<CR>template<typename ty>mint operator*(const ty&oth)const{return mint(*this)*=oth;}\<CR>mint operator/(const mint&oth)const{return mint(*this)/=oth;}\<CR>template<typename ty>mint operator/(const ty&oth)const{return mint(*this)/=oth;}\<CR>mint operator%(const mint&oth)const{return mint(*this)%=oth;}\<CR>template<typename ty>mint operator%(const ty&oth)const{return mint(*this)%=oth;}\<CR>mint&operator++(){return(*this)+=mint(1);}\<CR>mint&operator--(){return(*this)-=mint(1);}\<CR>mint operator++(signed){mint tmp(*this);++(*this);return tmp;}\<CR>mint operator--(signed){mint tmp(*this);--(*this);return tmp;}\<CR>mint operator+(){return mint(*this);}\<CR>mint operator-(){return mint()-(*this);}\<CR>friend ostream&operator<<(ostream&os,const mint&oth){return os<<oth.val;}\<CR>friend istream&operator>>(istream&is,mint&oth){is>>oth.val;oth.val%=mod;return is;}\<CR>template<typename ty>friend ty&operator+=(ty&val,const mint&oth){return val+=static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty&operator-=(ty&val,const mint&oth){return val-=static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty&operator*=(ty&val,const mint&oth){return val*=static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty&operator/=(ty&val,const mint&oth){return val/=static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty&operator%=(ty&val,const mint&oth){return val%=static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty operator+(const ty&val,const mint&oth){return val+static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty operator-(const ty&val,const mint&oth){return val-static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty operator*(const ty&val,const mint&oth){return val*static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty operator/(const ty&val,const mint&oth){return val/static_cast<ty>(oth.val);}\<CR>template<typename ty>friend ty operator%(const ty&val,const mint&oth){return val%static_cast<ty>(oth.val);}\<CR>template<typename ty>friend bool operator<(const ty&val,const mint&oth){return val<static_cast<ty>(oth.val);}\<CR>template<typename ty>friend bool operator>(const ty&val,const mint&oth){return val>static_cast<ty>(oth.val);}\<CR>template<typename ty>friend bool operator==(const ty&val,const mint&oth){return val==static_cast<ty>(oth.val);}\<CR>template<typename ty>friend bool operator!=(const ty&val,const mint&oth){return val!=static_cast<ty>(oth.val);}\<CR>template<typename ty>friend bool operator<=(const ty&val,const mint&oth){return val<=static_cast<ty>(oth.val);}\<CR>template<typename ty>friend bool operator>=(const ty&val,const mint&oth){return val>=static_cast<ty>(oth.val);}\<CR>};\<CR>template<const unsigned int mod=18446744073709551557ULL>inline mint<mod>inverse(const mint<mod>&val){return mint<mod>(inverse(static_cast<unsigned int>(val),mod));}\<CR>#endif"
		exec delcmd
	elseif a:arg=="hld"
		if search("#ifndef __BINARY_LIFTING__")==0
			execute "normal! :C binary_lifting\<CR>"
			let curpos=getpos('.')
		else
			call setpos('.', curpos)
		endif
		if search("#ifndef __SEGTREE__")==0
			execute "normal! :C segtree\<CR>"
			let curpos=getpos('.')
		else
			call setpos('.', curpos)
		endif
		if search("#ifndef __HLD__")!=0
			call setpos('.', curpos)
			return
		endif
		execute initcmd
		exec "normal! a#ifndef __HLD__\<CR>#define __HLD__\<CR>template<typename value=unsigned char, typename func=__segtree_default_fn__<value>, typename lazy=__segtree_default_lz__<value>>class hld\<CR>{\<CR>binary_lifting lca;\<CR>func fn;\<CR>lazy lz;\<CR>struct node\<CR>{\<CR>node*prev;\<CR>segtree<value,func,lazy>*tr;\<CR>size_t dpth;\<CR>node():tr(nullptr){}\<CR>node(const node&oth):tr(oth.tr==nullptr?nullptr:new segtree<value,func,lazy>(*oth.tr)),dpth(oth.dpth){}\<CR>~node(){delete tr;}\<CR>};\<CR>value runfn(const value&a,const value&b)const{return fn(a,b);}\<CR>value runlz(const value&a,const value&b,size_t sz)const{return fn(a,b,sz);}\<CR>node*arr;\<CR>size_t sz, root1;\<CR>size_t checkParent(size_t val, const tree<value,void>&oth){return oth.parent(val);}\<CR>template<typename pathtype>size_t checkParent(size_t val, const tree<value,pathtype>&oth){return oth.parent(val).first;}\<CR>size_t getValue(size_t val){return val;}\<CR>template<typename pathtype>size_t getValue(const pair<size_t,pathtype>&val){return val.first;}\<CR>template<typename pathtype>void dfs(const tree<value,pathtype>&oth)\<CR>{\<CR>stack<pair<size_t,size_t>>st;\<CR>st.push(pair<size_t,size_t>(root1,root1));\<CR>vector<value>*vt = new vector<value>[sz]();\<CR>vector<size_t>segtrees;\<CR>while(!st.empty())\<CR>{\<CR>pair<size_t,size_t>t=st.top();\<CR>st.pop();\<CR>node*cur = arr+t.first;\<CR>cur->prev = arr+t.second;\<CR>cur->dpth = oth.height(t.first);\<CR>(vt+t.second)->push_back(oth[t.first]);\<CR>if(t.first == t.second)\<CR>cur->prev = arr+checkParent(t.first,oth), segtrees.push_back(t.first);\<CR>if(oth.children(t.first).size()==0)\<CR>continue;\<CR>decltype(oth.children(t.first).begin())start=oth.children(t.first).begin();\<CR>size_t mxSubtree = getValue(*start);\<CR>for(decltype(start)it=start, en=oth.children(t.first).end(); it!=en; ++it)\<CR>if(oth.subtree(mxSubtree) < oth.subtree(getValue(*it)))\<CR>mxSubtree = getValue(*it);\<CR>for(decltype(start)en=oth.children(t.first).end(); start!=en; ++start)\<CR>if(getValue(*start) == mxSubtree)\<CR>st.push(pair<size_t,size_t>(getValue(*start),t.second));\<CR>else\<CR>st.push(pair<size_t,size_t>(getValue(*start),getValue(*start)));\<CR>}\<CR>for(size_t i:segtrees)\<CR>(arr+i)->tr = new segtree<value,func,lazy>((vt+i)->begin(),(vt+i)->end(),fn,lz);\<CR>delete[]vt;\<CR>}\<CR>void initArr()\<CR>{\<CR>arr = (node*)malloc(sizeof(node) * sz);\<CR>for(node*it=arr, *en=arr+sz; it!=en; ++it)\<CR>new(it)node();\<CR>}\<CR>void initArr(node*oth)\<CR>{\<CR>arr = (node*)malloc(sizeof(node) * sz);\<CR>for(node*it=arr, *en=arr+sz, ft=oth; it!=en; ++it,++ft)\<CR>{\<CR>new(it)node(*ft);\<CR>it->prev = arr+(ft->prev-oth);\<CR>}\<CR>}\<CR>void deleteArr()\<CR>{\<CR>for(node*it=arr, *en=arr+sz; it!=en; ++it)\<CR>it->~node();\<CR>free(arr);\<CR>}\<CR>public:\<ESC><<A\<CR>hld(func fn=func(), lazy lz=lazy()):lca(binary_lifting()),fn(fn),lz(lz),arr(nullptr),sz(0),root1(0){}\<CR>hld(lazy lz):hld(func(),lz){}\<CR>template<typename pathtype>hld(const tree<value,pathtype>&tr, func fn=func(), lazy lz=lazy()):lca(tr),fn(fn),lz(lz),sz(tr.size()),root1(tr.root()){initArr(),dfs(tr);}\<CR>template<typename pathtype>hld(const tree<value,pathtype>&tr, lazy lz):lca(tr,func(),lz){}\<CR>hld(const hld&oth):lca(oth.lca),fn(oth.fn),lz(oth.lz),sz(oth.sz),root1(oth.root1){initArr(oth.arr);}\<CR>hld(hld&&oth):lca(move(oth.lca)),fn(oth.fn),lz(oth.lz),arr(oth.arr),sz(oth.sz),root1(oth.root1){oth.arr=nullptr,oth.sz=oth.root1=0;}\<CR>template<typename pathtype>void build(const tree<value,pathtype>&tr)\<CR>{\<CR>deleteArr();\<CR>lca.build(tr);\<CR>sz = tr.size();\<CR>root1 = tr.root();\<CR>initArr();\<CR>dfs(tr);\<CR>}\<CR>void build(const hld&oth)\<CR>{\<CR>deleteArr();\<CR>lca.build(oth.lca);\<CR>sz = oth.sz;\<CR>root1 = oth.root1;\<CR>initArr(oth.arr);\<CR>}\<CR>void build(hld&&oth)\<CR>{\<CR>deleteArr();\<CR>lca.build(move(oth.lca));\<CR>sz = oth.sz;\<CR>root1 = oth.root1;\<CR>arr = oth.arr;\<CR>oth.sz=oth.arr=0;\<CR>oth.arr=nullptr;\<CR>}\<CR>value query(size_t a, size_t b)const\<CR>{\<CR>node*ca = arr+a, *cb = arr+b;\<CR>if(a==b)\<CR>{\<CR>if(ca->tr == nullptr)\<CR>{\<CR>size_t pos = ca->dpth-ca->prev->dpth;\<CR>return ca->prev->tr->query(pos, pos);\<CR>}\<CR>return ca->tr->query(0,0);\<CR>}\<CR>size_t dpth = (arr+lca.lca(a,b))->dpth;\<CR>if(ca->dpth < cb->dpth)\<CR>swap(ca,cb);\<CR>value res;\<CR>bool initialized=false, prevLight=true;\<CR>caLabel:\<CR>if(ca->tr == nullptr)\<CR>{\<CR>prevLight = false;\<CR>size_t end = ca->dpth - ca->prev->dpth;\<CR>ca = ca->prev;\<CR>size_t begin = ca->dpth<dpth?dpth-ca->dpth:0;\<CR>if(initialized)\<CR>res = runfn(res, ca->tr->query(begin,end));\<CR>else\<CR>initialized = true, res = ca->tr->query(begin,end);\<CR>if(ca->dpth > dpth)\<CR>goto caLabel;\<CR>}\<CR>else\<CR>{\<CR>if(!initialized)\<CR>initialized = true, res = ca->tr->query(0,0);\<CR>else if(prevLight)\<CR>res = runfn(res, ca->tr->query(0,0));\<CR>prevLight = true;\<CR>ca = ca->prev;\<CR>if(ca->dpth >= dpth)\<CR>goto caLabel;\<CR>}\<CR>prevLight=true;\<CR>if(cb->dpth == dpth)\<CR>return res;\<CR>++dpth;\<CR>cbLabel:\<CR>if(cb->tr == nullptr)\<CR>{\<CR>prevLight = false;\<CR>size_t end = cb->dpth - cb->prev->dpth;\<CR>cb = cb->prev;\<CR>size_t begin = cb->dpth<dpth?dpth-cb->dpth:0;\<CR>if(initialized)\<CR>res = runfn(res, cb->tr->query(begin,end));\<CR>else\<CR>initialized = true, res = cb->tr->query(begin,end);\<CR>if(cb->dpth > dpth)\<CR>goto cbLabel;\<CR>}\<CR>else\<CR>{\<CR>if(!initialized)\<CR>initialized = true, res = ca->tr->query(0,0);\<CR>else if(prevLight)\<CR>res = runfn(res, ca->tr->query(0,0));\<CR>prevLight = true;\<CR>cb = cb->prev;\<CR>if(cb->dpth >= dpth)\<CR>goto cbLabel;\<CR>}\<CR>return res;\<CR>}\<CR>void update(size_t a, size_t b, const value&val)\<CR>{\<CR>node*ca = arr+a, *cb = arr+b;\<CR>if(a==b)\<CR>{\<CR>if(ca->tr == nullptr)\<CR>{\<CR>size_t pos = ca->dpth-ca->prev->dpth;\<CR>ca->prev->tr->update(pos, pos, val);\<CR>}\<CR>else\<CR>ca->tr->update(0,0,val);\<CR>return;\<CR>}\<CR>size_t dpth = (arr+lca.lca(a,b))->dpth;\<CR>if(ca->dpth < cb->dpth)\<CR>swap(ca,cb);\<CR>bool prevLight=true;\<CR>caLabel:\<CR>if(ca->tr == nullptr)\<CR>{\<CR>prevLight = false;\<CR>size_t end = ca->dpth - ca->prev->dpth;\<CR>ca = ca->prev;\<CR>size_t begin = ca->dpth<dpth?dpth-ca->dpth:0;\<CR>ca->tr->update(begin,end,val);\<CR>if(ca->dpth > dpth)\<CR>goto caLabel;\<CR>}\<CR>else\<CR>{\<CR>if(prevLight)\<CR>ca->tr->update(0,0,val);\<CR>prevLight = true;\<CR>ca = ca->prev;\<CR>if(ca->dpth >= dpth)\<CR>goto caLabel;\<CR>}\<CR>prevLight=true;\<CR>if(cb->dpth == dpth)\<CR>return;\<CR>++dpth;\<CR>cbLabel:\<CR>if(cb->tr == nullptr)\<CR>{\<CR>prevLight = false;\<CR>size_t end = cb->dpth - cb->prev->dpth;\<CR>cb = cb->prev;\<CR>size_t begin = cb->dpth<dpth?dpth-cb->dpth:0;\<CR>cb->tr->update(begin,end,val);\<CR>if(cb->dpth > dpth)\<CR>goto cbLabel;\<CR>}\<CR>else\<CR>{\<CR>if(prevLight)\<CR>ca->tr->update(0,0,val);\<CR>prevLight = true;\<CR>cb = cb->prev;\<CR>if(cb->dpth >= dpth)\<CR>goto cbLabel;\<CR>}\<CR>}\<CR>void update(size_t idx, const value&val)\<CR>{\<CR>node*ca = arr+idx;\<CR>if(ca->tr == nullptr)\<CR>ca->prev->tr.update(ca->dpth - ca->prev->dpth, val);\<CR>else\<CR>ca->tr->update(0,val);\<CR>}\<CR>value&operator[](size_t idx)\<CR>{\<CR>node*ptr = arr+idx;\<CR>if(ptr->tr == nullptr)\<CR>return ptr->prev->tr->operator[](ptr->dpth - ptr->prev->dpth);\<CR>return ptr->tr->operator[](0);\<CR>}\<CR>const value&operator[](size_t idx)const\<CR>{\<CR>node*ptr = arr+idx;\<CR>if(ptr->tr == nullptr)\<CR>return ptr->prev->tr->operator[](ptr->dpth - ptr->prev->dpth);\<CR>return ptr->tr->operator[](0);\<CR>}\<CR>size_t size()const{return sz;}\<CR>size_t root()const{return root1;}\<CR>};\<CR>#endif"
		exec delcmd
	elseif a:arg=="wavelettree"
		if search("#ifndef __WAVLETTREE__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __WAVLETTREE__\<CR>#define __WAVLETTREE__\<CR>template<typename container>struct __wavlettree_def_build__\<CR>{\<CR>container operator()(const container&first,const container&second)const\<CR>{\<CR>container res(first.size()+second.size());\<CR>decltype(res.begin())st=res.begin();\<CR>for(decltype(first.begin())it=first.begin(), en=first.end(); it!=en; ++it)\<CR>{\<CR>*st = *it;\<CR>++st;\<CR>}\<CR>for(decltype(second.begin())it=second.begin(), en=second.end(); it!=en; ++it)\<CR>{\<CR>*st = *it;\<CR>++st;\<CR>}\<CR>sort(res.begin(), res.end());\<CR>return res;\<CR>}\<CR>};\<CR>template<typename container>struct __wavlettree_def_init__\<CR>{\<CR>template<typename value>container operator()(const value&element)const\<CR>{\<CR>container tmp(1);\<CR>*tmp.begin() = element;\<CR>return tmp;\<CR>}\<CR>};\<CR>template<typename container>struct __wavlettree_def_convert__\<CR>{\<CR>template<typename value>size_t operator()(const container&cont, const value&val)const\<CR>{\<CR>return upper_bound(cont.begin(), cont.end(), val) - lower_bound(cont.begin(), cont.end(), val);\<CR>}\<CR>};\<CR>template<typename container>struct __wavlettree_def_combine__\<CR>{\<CR>size_t operator()(size_t a, size_t b)const{return a+b;}\<CR>};\<CR>template<typename value, typename retval=size_t, typename container=vector<value>, typename init=__wavlettree_def_init__<container>, typename buildType=__wavlettree_def_build__<container>, typename convert=__wavlettree_def_convert__<container>, typename combine=__wavlettree_def_combine__<container>>class wavelettree\<CR>{\<CR>init in;\<CR>buildType bl;\<CR>convert cn;\<CR>combine cm;\<CR>struct node\<CR>{\<CR>container*cnt;\<CR>node*a, *b;\<CR>node():cnt(nullptr),a(nullptr),b(nullptr){}\<CR>~node(){delete cnt;}\<CR>};\<CR>node*root;\<CR>size_t sz;\<CR>container runBuild(const container&a, const container&b)const{return bl(a,b);}\<CR>container runInit(const value&b)const{return in(b);}\<CR>template<typename val1>retval runConvert(const container&cont, const val1&val)const{return cn(cont,val);}\<CR>retval runCombine(const retval&va, const retval&vb)const{return cm(va,vb);}\<CR>template<typename iter>void buildBruh(node*nd, size_t l, size_t r, iter&begin)\<CR>{\<CR>if(l==r)\<CR>{\<CR>nd->cnt = new container(runInit(*begin));\<CR>++begin;\<CR>return;\<CR>}\<CR>size_t mid = (l+r)>>1;\<CR>buildBruh(nd->a=new node(), l, mid, begin);\<CR>buildBruh(nd->b=new node(), mid+1, r, begin);\<CR>nd->cnt = new container(runBuild(*(nd->a->cnt), *(nd->b->cnt)));\<CR>}\<CR>void copy(node*nd, size_t l, size_t r, node*oth)\<CR>{\<CR>nd->cnt = new container(*(oth->cnt));\<CR>if(l==r)\<CR>return;\<CR>size_t mid = (l+r)>>1;\<CR>copy(nd->a=new node(), l, mid, oth->a);\<CR>copy(nd->b=new node(), mid+1, r, oth->b);\<CR>}\<CR>void destroy(node*nd, size_t l, size_t r)\<CR>{\<CR>if(l==r)\<CR>{\<CR>delete nd;\<CR>return;\<CR>}\<CR>size_t mid = (l+r)>>1;\<CR>destroy(nd->a, l, mid);\<CR>destroy(nd->b, mid+1, r);\<CR>delete nd;\<CR>}\<CR>template<typename val1>retval query(node*tr, size_t l, size_t r, size_t ql, size_t qr, const val1&val)const\<CR>{\<CR>if(l>=ql && r<=qr)\<CR>return runConvert(*(tr->cnt), val);\<CR>size_t mid = (l+r)>>1;\<CR>if(mid >= ql)\<CR>{\<CR>if(mid < qr)\<CR>return runCombine(query(tr->a, l, mid, ql, qr, val), query(tr->b, mid+1, r, ql, qr, val));\<CR>return query(tr->a, l, mid, ql, qr, val);\<CR>}\<CR>return query(tr->b, mid+1, r, ql, qr, val);\<CR>}\<CR>public:\<ESC><<A\<CR>wavelettree(init in, buildType bl, convert cn, combine cm):in(in),bl(bl),cn(cn),cm(cm),root(nullptr),sz(0){}\<CR>wavelettree():wavelettree(buildType(),init(),convert(),combine()){}\<CR>wavelettree(initializer_list<value>lst, init in, buildType bl, convert cn, combine cm):wavelettree(lst.begin(),lst.end(),in,bl,cn,cm){}\<CR>wavelettree(initializer_list<value>lst):wavelettree(lst.begin(),lst.end(),buildType(),init(),convert(),combine()){}\<CR>template<typename iter>wavelettree(iter begin, iter end, init in, buildType bl, convert cn, combine cm):in(in),bl(bl),cn(cn),cm(cm),root(new node()),sz(distance(begin,end)){buildBruh(root, 0, sz-1, begin);}\<CR>template<typename iter>wavelettree(iter begin, iter end):wavelettree(begin,end,init(),buildType(),convert(),combine()){}\<CR>wavelettree(const wavelettree&oth):in(oth.in),bl(oth.bl),cn(oth.cn),cm(oth.cm),sz(oth.sz)\<CR>{\<CR>if(sz)\<CR>copy(root=new node(), 0, sz-1, oth.root);\<CR>else\<CR>root = nullptr;\<CR>}\<CR>wavelettree(wavelettree&&oth):in(oth.in),bl(oth.bl),cn(oth.cn),cm(oth.cm),root(oth.root),sz(oth.sz)\<CR>{\<CR>oth.root=nullptr;\<CR>oth.sz=0;\<CR>}\<CR>~wavelettree(){if(sz!=0)destroy(root,0,sz-1);}\<CR>void build(){if(sz!=0)destroy(root,0,sz-1);root=nullptr,sz=0;}\<CR>void build(const wavelettree&oth){if(oth.root==root)return;if(sz!=0)destroy(root,0,sz-1);sz=oth.sz;if(sz){root=new node();copy(root,0,sz-1,oth.root);}else root=nullptr;}\<CR>void build(wavelettree&&oth){if(oth.root==root)return;if(sz!=0)destroy(root,0,sz-1);sz=oth.sz,root=oth.root,oth.sz=0,oth.root=nullptr;}\<CR>wavelettree&operator=(const wavelettree&oth){build(oth);return*this;}\<CR>wavelettree&operator=(wavelettree&&oth){build(oth);return*this;}\<CR>template<typename val1>retval query(size_t begin, size_t end, const val1&val)const{return query(root, 0, sz-1, begin, end, val);}\<CR>size_t size()const{return sz;}\<CR>};\<CR>#endif"
		exec delcmd
	elseif a:arg == "base"
		if search("#ifndef __BASE__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __BASE__\<CR>#define __BASE__\<CR>inline string base(int n, size_t base=10, const string&charset=string(\"0123456789ABCDEF\"))\<CR>{\<CR>bool isNeg = n<0;\<CR>if(base < 2)\<CR>throw new invalid_argument(\"base cannot be lower than 2\");\<CR>if(n == 0)\<CR>return string(charset[0], 1);\<CR>string res;\<CR>while(n > 0)\<CR>{\<CR>res += charset[n%base];\<CR>n /= base;\<CR>}\<CR>if(isNeg)\<CR>res += '-';\<CR>reverse(res.begin(), res.end());\<CR>return res;\<CR>}\<CR>#endif\<ESC>"
		exec delcmd
	elseif a:arg=="binary_search"
		if search("#ifndef __BINARY_SEARCH__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __BINARY_SEARCH__\<CR>#define __BINARY_SEARCH__\<CR>template<typename func>inline unsigned int __binary_search__(unsigned int begin, unsigned int end, func fn=func())\<CR>{\<CR>while(begin < end)\<CR>{\<CR>size_t mid = begin+((end-begin)>>1);\<CR>if(fn(mid))\<CR>begin = mid+1;\<CR>else\<CR>end = mid;\<CR>}\<CR>return begin;\<CR>}\<CR>template<typename func>inline double __binary_search__(double begin, double end, double accuracy, func fn=func())\<CR>{\<CR>while(end-begin > accuracy)\<CR>{\<CR>double mid = (end+begin) * 0.5L;\<CR>if(fn(mid))\<CR>begin = mid;\<CR>else\<CR>end = mid;\<CR>}\<CR>return begin;\<CR>}\<CR>template<typename iter, typename val, typename comp=less<typename iterator_traits<iter>::value_type>>\<CR>inline bool __binary_search__(iter begin, iter end, const val&v, comp cmp=comp()){return binary_search(begin,end,v,cmp);}\<CR>#endif" . g:bf1 . "\<ESC>ggo#define binary_search __binary_search__\<ESC>G?" . g:bf1 . "\<CR>v$\"_d"
		exec delcmd
	elseif a:arg == "base"
		if search("#ifndef __BASE__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __BASE__\<CR>#define __BASE__\<CR>inline string base(int n, size_t base=10, const string&charset=string(\"0123456789ABCDEF\"))\<CR>{\<CR>bool isNeg = n<0;\<CR>if(base < 2)\<CR>throw new invalid_argument(\"base cannot be lower than 2\");\<CR>if(n == 0)\<CR>return string(charset[0], 1);\<CR>string res;\<CR>while(n > 0)\<CR>{\<CR>res += charset[n%base];\<CR>n /= base;\<CR>}\<CR>if(isNeg)\<CR>res += '-';\<CR>reverse(res.begin(), res.end());\<CR>return res;\<CR>}\<CR>#endif\<ESC>"
		exec delcmd
	elseif a:arg == "sparse_table"
		if search("#ifndef __SPARSE_TABLE__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! A#ifndef __SPARSE_TABLE__\<CR>#define __SPARSE_TABLE__\<CR>template<typename ty>struct __sparse_table_def_query_min__{ty operator()(const ty&a,const ty&b)const{return min(a,b);};};\<CR>template<typename ty>struct __sparse_table_def_query_max__{ty operator()(const ty&a,const ty&b)const{return max(a,b);};};\<CR>template<typename ty,typename func=__sparse_table_def_query_min__<ty>>class sparse_table\<CR>{\<CR>static size_t countl_zero(unsigned long long b){return __builtin_clzll(b);}\<CR>static size_t countl_zero(unsigned long b){return __builtin_clzl(b);}\<CR>static size_t countl_zero(unsigned b){return __builtin_clz(b);}\<CR>func fn;\<CR>size_t sz,log2;\<CR>ty**table;\<CR>ty runfn(const ty&a, const ty&b)const{return fn(a,b);}\<CR>void constructFwd()\<CR>{\<CR>for(size_t j=1; j<log2; j++)\<CR>for(ty**it=table, **en=table+sz-(static_cast<size_t>(1)<<j)+1; it!=en; ++it)\<CR>*((*it)+j) = runfn(*((*it)+(j-1)), *((*(it+(static_cast<size_t>(1)<<(j-1))))+(j-1)));\<CR>}\<CR>void construct()\<CR>{\<CR>log2 = sizeof(size_t)*8-countl_zero(sz)-1;\<CR>size_t cpy=log2, dist=sz;\<CR>for(ty**it=table, **en=table+sz; it!=en; ++it,--dist)\<CR>{\<CR>*it = new ty[log2+1]();\<CR>if((static_cast<size_t>(1)<<log2) == dist)\<CR>--log2;\<CR>}\<CR>log2=cpy+1;\<CR>constructFwd();\<CR>}\<CR>void construct(const ty&fill)\<CR>{\<CR>log2 = sizeof(size_t)*8-countl_zero(sz)-1;\<CR>size_t cpy=log2, dist=sz;\<CR>for(ty**it=table, **en=table+sz; it!=en; ++it,--dist)\<CR>{\<CR>*it = new ty[log2+1]();\<CR>*(*it) = fill;\<CR>if((static_cast<size_t>(1)<<log2) == dist)\<CR>--log2;\<CR>}\<CR>log2=cpy+1;\<CR>constructFwd();\<CR>}\<CR>void construct(const sparse_table&oth)\<CR>{\<CR>log2 = sizeof(size_t)*8-countl_zero(sz)-1;\<CR>size_t cpy=log2, dist=sz;\<CR>for(ty**it=table, **en=table+sz, **othIt=oth.table; it!=en; ++it,--dist,++othIt)\<CR>{\<CR>*it = new ty[log2+1]();\<CR>*(*it) = *(*othIt);\<CR>if((static_cast<size_t>(1)<<log2) == dist)\<CR>--log2;\<CR>}\<CR>log2=cpy+1;\<CR>constructFwd();\<CR>}\<CR>template<typename iter>void construct(iter begin)\<CR>{\<CR>log2 = sizeof(size_t)*8-countl_zero(sz)-1;\<CR>size_t cpy=log2, dist=sz;\<CR>for(ty**it=table, **en=table+sz; it!=en; ++it,--dist,++begin)\<CR>{\<CR>*it = new ty[log2+1]();\<CR>*(*it) = *begin;\<CR>if((static_cast<size_t>(1)<<log2) == dist)\<CR>--log2;\<CR>}\<CR>log2=cpy+1;\<CR>constructFwd();\<CR>}\<CR>void destruct()\<CR>{\<CR>for(ty**it=table, **en=table+sz; it!=en; ++it)\<CR>delete[](*it);\<CR>delete[]table;\<CR>}\<CR>public:\<ESC><<A\<CR>sparse_table(func fn=func()):fn(fn),sz(0),table(nullptr){}\<CR>sparse_table(size_t sz, func fn=func()):fn(fn),sz(sz),table(new ty*[sz]){construct();}\<CR>sparse_table(size_t sz, const ty&fill, func fn=func()):fn(fn),sz(sz),table(new ty*[sz]){construct(fill);}\<CR>sparse_table(initializer_list<ty>lst, func fn=func()):sparse_table(lst.begin(),lst.end(),fn){}\<CR>template<typename iter>sparse_table(iter begin, iter end, func fn=func()):fn(fn),sz(distance(begin,end)),table(new ty*[sz]){construct(begin);}\<CR>sparse_table(const sparse_table&oth):fn(oth.fn),sz(oth.sz),table(new ty*[sz]){construct(oth);}\<CR>sparse_table(sparse_table&&oth):fn(oth.fn),sz(oth.sz),table(oth.table){oth.sz=0,oth.table=nullptr;}\<CR>~sparse_table(){destruct();}\<CR>void build(size_t sz)\<CR>{\<CR>destruct();\<CR>this->sz = sz;\<CR>table = new ty*[sz];\<CR>construct();\<CR>}\<CR>void build(size_t sz, const ty&fill)\<CR>{\<CR>destruct();\<CR>this->sz = sz;\<CR>table = new ty*[sz];\<CR>construct(fill);\<CR>}\<CR>template<typename iter>void build(iter begin, iter end)\<CR>{\<CR>destruct();\<CR>this->sz = distance(begin,end);\<CR>table = new ty*[sz];\<CR>construct(begin);\<CR>}\<CR>void build(initializer_list<ty>lst){build(lst.begin(),lst.end());}\<CR>void build(const sparse_table&oth)\<CR>{\<CR>destruct();\<CR>sz = oth.sz;\<CR>table = new ty*[sz];\<CR>construct(oth);\<CR>}\<CR>void build(sparse_table&&oth)\<CR>{\<CR>destruct();\<CR>sz = oth.sz;\<CR>table = oth.table;\<CR>oth.sz=0;\<CR>oth.table=nullptr;\<CR>}\<CR>size_t size()const{return sz;}\<CR>sparse_table&operator=(const sparse_table&oth){build(oth);return*this;}\<CR>sparse_table&operator=(sparse_table&&oth){build(oth);return*this;}\<CR>sparse_table&operator=(initializer_list<ty>lst){build(lst);return*this;}\<CR>ty query(size_t left, size_t right)const\<CR>{\<CR>size_t dist = right-left+1;\<CR>size_t log2 = sizeof(size_t)*8-countl_zero(dist)-1;\<CR>if(dist == static_cast<size_t>(1)<<log2)\<CR>return *(*(table+left)+log2);\<CR>return runfn(*(*(table+left)+log2), *(*(table+right-(static_cast<size_t>(1)<<log2)+1)+log2));\<CR>}\<CR>const ty&operator[](size_t idx)const{return *(*(table+idx));}\<CR>};\<CR>template<typename ty>using min_sparse_table=sparse_table<ty,__sparse_table_def_query_min__<ty>>;\<CR>template<typename ty>using max_sparse_table=sparse_table<ty,__sparse_table_def_query_max__<ty>>;\<CR>#endif"
		exec delcmd
	elseif a:arg=="prefix_array"
		if search("#ifndef __PREFIX_ARRAY__")!=0
			call setpos('.', curpos)
			return
		endif
		exec initcmd
		exec "normal! a#ifndef __PREFIX_ARRAY__\<CR>#define __PREFIX_ARRAY__\<CR>template<typename ty>struct __prefix_array_def_fwd__{ty operator()(const ty&a,const ty&b)const{return a+b;}};\<CR>template<typename ty>struct __prefix_array_def_bwd__{ty operator()(const ty&a,const ty&b)const{return b-a;}};\<CR>template<typename ty, typename fwd=__prefix_array_def_fwd__<ty>, typename bwd=__prefix_array_def_bwd__<ty>>class prefix_array\<CR>{\<CR>size_t sz;\<CR>fwd f1;\<CR>bwd f2;\<CR>ty runfwd(const ty&a, const ty&b)const{return f1(a,b);}\<CR>ty runbwd(const ty&a, const ty&b)const{return f2(a,b);}\<CR>ty*arr;\<CR>void pfx()\<CR>{\<CR>if(sz!=0)\<CR>for(ty*it=arr+1, *en=arr+sz; it!=en; ++it)\<CR>*it = runfwd(*it, *(it-1));\<CR>}\<CR>public:\<ESC><<A\<CR>prefix_array(fwd f1=fwd(),bwd f2=bwd()):sz(0),f1(f1),f2(f2),arr(nullptr){}\<CR>prefix_array(bwd b1):prefix_array(fwd(),b1){}\<CR>prefix_array(size_t sz, fwd f1=fwd(), bwd f2=bwd()):sz(sz),f1(f1),f2(f2),arr(new ty[sz]()){}\<CR>prefix_array(size_t sz, bwd b1):prefix_array(sz, fwd(), b1){}\<CR>template<typename iter>prefix_array(iter begin, iter end, fwd f1=fwd(), bwd f2=bwd()):sz(distance(begin,end)),f1(f1),f2(f2),arr(new ty[sz]()){copy(begin,end,arr),pfx();}\<CR>template<typename iter>prefix_array(iter begin, iter end, bwd b1):prefix_array(begin,end,fwd(),b1){}\<CR>prefix_array(initializer_list<ty>lst, fwd f1=fwd(), bwd f2=bwd()):prefix_array(lst.begin(),lst.end(),f1,f2){}\<CR>prefix_array(initializer_list<ty>lst, bwd b1):prefix_array(lst.begin(),lst.end(),fwd(),b1){}\<CR>prefix_array(const prefix_array&oth):sz(oth.sz),f1(oth.f1),f2(oth.f2),arr(new ty[sz]()){copy(oth.arr,oth.arr+sz,arr);}\<CR>prefix_array(prefix_array&&oth):sz(oth.sz),f1(oth.f1),f2(oth.f2),arr(oth.arr){oth.arr=nullptr,oth.sz=0;}\<CR>~prefix_array(){delete[]arr;}\<CR>size_t size()const{return sz;}\<CR>const ty&operator[](size_t idx)const{return*(arr+idx);}\<CR>void build(size_t sz)\<CR>{\<CR>delete[]arr;\<CR>this->sz = sz;\<CR>arr = new ty[sz]();\<CR>}\<CR>template<typename iter>void build(iter begin, iter end)\<CR>{\<CR>delete[]arr;\<CR>sz = distance(begin,end);\<CR>arr = new ty[sz]();\<CR>copy(begin,end,arr);\<CR>pfx();\<CR>}\<CR>void build(initializer_list<ty>lst){build(lst.begin(),lst.end());}\<CR>void build(const prefix_array&oth)\<CR>{\<CR>delete[]arr;\<CR>sz=oth.sz;\<CR>arr=new ty[sz]();\<CR>copy(oth.arr,oth.arr+sz,arr);\<CR>}\<CR>void build(prefix_array&&oth)\<CR>{\<CR>delete[]arr;\<CR>sz=oth.sz;\<CR>arr=oth.arr;\<CR>oth.sz=0;\<CR>oth.arr=nullptr;\<CR>}\<CR>prefix_array&operator=(const prefix_array&oth){build(oth);return*this;}\<CR>prefix_array&operator=(prefix_array&&oth){build(oth);return*this;}\<CR>prefix_array&operator=(initializer_list<ty>lst){build(lst);return*this;}\<CR>ty query(size_t l, size_t r)const{if(l==0)return*(arr+r);return runbwd(*(arr+(l-1)), *(arr+r));}\<CR>ty operator[](size_t idx){return query(idx,idx);}\<CR>};\<CR>#endif"
		exec delcmd
	elseif a:arg=="all"
		for item in g:completions
			if (item!='all') && (item!='cases') && (item!='caseless')
				exec 'normal! :C ' . item . "\<CR>"
			endif
		endfor
	else
		echo "NO TEMPLATE FOUND"
		return
	endif
endfunction





function! Hack(arg)
	let bf = g:bf1
	let brh_id = synIDtrans(hlID("Normal"))
	let ctermfg = synIDattr(brh_id, "fg", "cterm")
	let ctermbg = synIDattr(brh_id, "bg", "cterm")
	let rnd = "____" 
	let strbruh = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890"
	let cf = ''
	for i in range(1,38)
		let cf = cf . strbruh[rand() % len(strbruh)]
	endfor
	for i in range(1,50)
		let rnd = rnd . strbruh[rand() % len(strbruh)]
	endfor
	let rnd = rnd . ";"
	let cmdogheight = &cmdheight . ""
	let oth2 = "Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>Ajjj:::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>"
	let initcmd = "normal! :silent vsp\<CR>:silent q!\<CR>:silent set cmdheight=69420\<CR>a" . rnd . "\<ESC>gg:call search(\"" . rnd . "\")\<CR>AA\<BS>\<ESC>gg:call search(\"" . bf . "\")\<CR>jO\<CR>\<CR>\<ESC>"
	let delcmd = "normal! Aa\<BS>bruh\<BS>\<BS>\<BS>\<BS>" . cf . "\<ESC>ggGggGggGgg:silent call search(\".\")\<CR>ggGggARANDOM :::\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>ABEE\<BS>\<BS>\<BS>\<ESC>:silent call search(\"Congratulations! You have found a text that nobody cares about! Finding out this text means that you have no life, and are will take countless hours just to do something so meaningless. Nobody will congratulate you for what you have discovered. Its just another easter egg amongst the thousands awaiting to be discovered. But there's no purpose. So, I guess congratulations to you. Good job for discovering this easter egg.\")\<CR>" . oth2 . "IARE\<BS>\<BS>\<BS>\<ESC>GASLASH\<BS>\<BS>\<BS>\<BS>\<BS>\<ESC>gg:silent call search(\"" . bf . "\")\<CR>A\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<ESC>gg:silent call search(\"" . cf . "\")\<CR>A\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h> // " . bf . "\<ESC>gg:silent call search(\"" . rnd . "\")\<CR>54la\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<ESC>zz:set cmdheight=" . cmdogheight . "\<CR>:redraw\<CR>"
	let curpos=getpos('.')
	if a:arg=="c++17_ump"
		if search("#ifndef __HACK_CPP17_UMP__")!=0
			call setpos('.', curpos)
		else
			exec initcmd
			exec "normal! a#ifndef __HACK_CPP17_UMP__\<CR>#define __HACK_CPP17_UMP__\<CR>inline vector<int>hack()\<CR>{\<CR>int cur=0;\<CR>vector<int>res(20000);\<CR>for(size_t i=0; i<20000; i++)\<CR>res[i] = cur+=26267;\<CR>mt19937 rng(17);\<CR>shuffle(res.begin(), res.end(), rng);\<CR>return res;\<CR>}\<CR>#endif"
			exec delcmd
		endif
	elseif a:arg=="c++20_ump"
		if search("#ifndef __HACK_CPP20_UMP__")!=0
			call setpos('.', curpos)
		else
			exec initcmd
			exec "normal! a#ifndef __HACK_CPP20_UMP__\<CR>#define __HACK_CPP20_UMP__\<CR>inline vector<int>hack()\<CR>{\<CR>int cur=0;\<CR>vector<int>res(20000);\<CR>for(size_t i=0; i<20000; i++)\<CR>res[i] = cur+=20753;\<CR>mt19937 rng(20);\<CR>shuffle(res.begin(), res.end(), rng);\<CR>return res;\<CR>}\<CR>#endif"
			exec delcmd
		endif
	elseif a:arg=="c++23_ump"
		if search("#ifndef __HACK_CPP23_UMP__")!=0
			call setpos('.', curpos)
		else
			exec initcmd
			exec "normal! a#ifndef __HACK_CPP23_UMP__\<CR>#define __HACK_CPP23_UMP__\<CR>inline vector<int>hack()\<CR>{\<CR>int cur=0;\<CR>vector<int>res(20000);\<CR>for(size_t i=0; i<20000; i++)\<CR>res[i] = cur+=20753;\<CR>mt19937 rng(23);\<CR>shuffle(res.begin(), res.end(), rng);\<CR>return res;\<CR>}\<CR>#endif"
			exec delcmd
		endif
	elseif a:arg=="java8_sort"
		if search("#ifndef __HACK_JAVA_8_SORT__")!=0
			call setpos('.', curpos)
		else
			exec initcmd
			exec "normal! A#ifndef __HACK_JAVA_8_SORT__\<CR>#define __HACK_JAVA_8_SORT__\<CR>inline vector<int>hack(size_t n)\<CR>{\<CR>vector<int>res;\<CR>int subVal=n;\<CR>int addVal=1;\<CR>int mxVal = (int)n+1;\<CR>pair<int,size_t>*a = (pair<int,size_t>*)malloc(sizeof(pair<int,size_t>)*n);\<CR>auto srt = [&](int left, int right, auto srt)->void\<CR>{\<CR>int length = right-left+1;\<CR>if(length < 47)\<CR>{\<CR>for(int i=left; i<=right; i++)\<CR>if(a[i].first==mxVal)\<CR>a[i].first = subVal--;\<CR>return;\<CR>}\<CR>int seventh = (length >> 3) + (length >> 6) + 1;\<CR>int e3 = (left + right) >> 1;\<CR>int e2 = e3 - seventh;\<CR>int e1 = e2 - seventh;\<CR>int e4 = e3 + seventh;\<CR>int e5 = e4 + seventh;\<CR>if(a[e5].first==mxVal)\<CR>a[e5].first = addVal++;\<CR>if(a[e3].first==mxVal)\<CR>a[e3].first = addVal++;\<CR>if(a[e1].first==mxVal)\<CR>a[e1].first = addVal++;\<CR>if(a[e4].first==mxVal)\<CR>a[e4].first = addVal++;\<CR>if(a[e2].first==mxVal)\<CR>a[e2].first = addVal++;\<CR>pair<int,size_t>lst[] = {a[e1], a[e2], a[e3], a[e4], a[e5]};\<CR>sort(lst, lst+5);\<CR>a[e1]=lst[0], a[e2]=lst[1], a[e3]=lst[2], a[e4]=lst[3], a[e5]=lst[4];\<CR>int less = left;\<CR>int great = right;\<CR>pair pivot1 = a[e2], pivot2 = a[e4];\<CR>a[e2] = a[left];\<CR>a[e4] = a[right];\<CR>while(a[++less]<pivot1);\<CR>while(a[--great]>pivot2);\<CR>for(int k=less-1; ++k<=great;)\<CR>{\<CR>if(a[k] < pivot1)\<CR>swap(a[less++], a[k]);\<CR>else\<CR>{\<CR>while(a[great] > pivot2)\<CR>if(great-- == k)\<CR>goto outer1;\<CR>pair tmp = a[k];\<CR>if(a[great] < pivot1)\<CR>{\<CR>a[k] = a[less];\<CR>a[less] = a[great];\<CR>++less;\<CR>}\<CR>else\<CR>a[k] = a[great];\<CR>a[great] = tmp;\<CR>--great;\<CR>}\<CR>}\<CR>outer1:\<CR>a[left] = a[less-1];\<CR>a[less-1] = pivot1;\<CR>a[right] = a[great+1];\<CR>a[great+1] = pivot2;\<CR>srt(left, less-2, srt);\<CR>srt(great+2, right, srt);\<CR>srt(less, great, srt);\<CR>};\<CR>for(size_t i=0; i<n; i++)\<CR>a[i] = {mxVal, i};\<CR>for(size_t i=0; i<67; i++)\<CR>a[i*2+1].first = addVal++, a[i*2].first = addVal++;\<CR>sort(a, a+134);\<CR>srt(0,subVal-1,srt);\<CR>res.resize(n);\<CR>for(size_t i=0; i<n; i++)\<CR>res[a[i].second] = a[i].first;\<CR>free(a);\<CR>return res;\<CR>}\<CR>#endif"
			exec delcmd
		endif
	elseif a:arg=="c_qsort"
		if search("#ifndef __HACK_C_QSORT__")!=0
			call setpos('.', curpos)
		else
			exec initcmd
			exec "normal! A#ifndef __HACK_C_QSORT__\<CR>#define __HACK_C_QSORT__\<CR>inline vector<int>hack(size_t n)\<CR>{\<CR>vector<int>res(n*2+1);\<CR>for(size_t i=0; i<n*2+1; i++)\<CR>res[i] = i+1;\<CR>for(size_t i=0; i<n; i++)\<CR>swap(res[2*n-2*i-1], res[2*n-i-1]);\<CR>return res;\<CR>}\<CR>#endif"
			exec delcmd
		endif
	elseif a:arg==#""
	else
		echo "NO HACKS FOUND"
		return
	endif
	new
	e D:\Vim\hacks.txt
	set readonly
	set nomodifiable
	if a:arg==#""
	else
		exec "normal! gg\<CR>/".a:arg."\<CR>^zt"
	endif
endfunction





	

let g:types = ["dsu", "segtree", "graph", "tree", "binary_lifting", "array_hash", "hld", "mint", "wavelettree", "sparse_table", "prefix_array"]
let g:subtypes = ["min_sparse_table", "max_sparse_table"]
let g:functions = ["caseless", "cases", "inverse", "fibonacci", "prime", "factor", "factorial", "ncr", "base", "binary_search", "all"]
let g:hacks = ["c++17_ump", "c++20_ump", "c++23_ump", "java8_sort", "c_qsort"]
let tmp = copy(g:types) + copy(g:subtypes)
hi CustomDefine ctermfg=2
let pattern = '' . join(tmp, ' ') . ''
autocmd FileType cpp execute "syn keyword CustomDefine " . pattern . ""
autocmd FileType cuda execute "syn keyword CustomDefine " . pattern . ""
let g:completions = g:types + g:functions
call sort(g:completions)
function! CustomCompletion(A,L,P) abort
    let filtered_completions = []
    for option in g:completions
        if stridx(option, a:A) == 0
            call add(filtered_completions, option)
        endif
    endfor
    return filtered_completions
endfunction
function! CustomHackLetion(A,L,P) abort
    let filtered_completions = []
    for option in g:hacks
        if stridx(option, a:A) == 0
            call add(filtered_completions, option)
        endif
    endfor
    return filtered_completions
endfunction
function! MCommand()
	exec "normal! A\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<ESC>^lllllllllllli\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<C-h>\<ESC>^"
endfunction
set more

command! -nargs=1 -complete=customlist,CustomCompletion Construct call Global(<f-args>)
command! -nargs=? -complete=customlist,CustomHackLetion Hack call Hack(<q-args>)
command! Build call Build()


function! Run_command(...)
	let l:bruh = copy(a:000)
	for i in range(len(l:bruh))
		let l:bruh[i]='"' . l:bruh[i] . '"'
	endfor
	let l:args = join(l:bruh, ' ')
	exec '!@echo off & color 09 & cls & cfThief submit ' . l:args . ''
endfunction
function! Contest(...)
	let l:bruh = copy(a:000)
	for i in range(len(l:bruh))
		let l:bruh[i] = '"' . l:bruh[i] . '"'
	endfor
	let l:args = join(l:bruh, ' ')
	exec '!@echo off & color 09 & cls & cfThief problem ' . l:args . ''
endfunction


command! -nargs=* Submit call Run_command(<f-args>)
command! -nargs=* Problem call Contest(<f-args>)


autocmd VimEnter * execute 'delcommand Sexplore'
autocmd VimEnter * execute 'delcommand Pexplore'
autocmd VimEnter * execute 'delcommand Texplore'
autocmd VimEnter * execute 'delcommand TOhtml'
autocmd VimEnter * execute 'delcommand Hexplore'


let gbruhf = v:false
let timer = 0

let isF = v:true


function! Pause(timer)
	let g:isF = v:true
endfunction


set updatetime=3000
autocmd CmdLineLeave * exec 'let g:isF = v:false | call timer_start(3000, "Pause")'
autocmd CmdLineEnter * exec 'let g:isF = v:false'


let jobId = 0
let cont1 = [' ']
function! ConstantEcho(...)
	if g:isF
		let cont = readfile('D:/Vim/out.txt')
		if len(cont)>0
			let g:cont1 = cont
		endif
		let lineNum = len(g:cont1)-1

		while lineNum != -1
			if g:cont1[lineNum] != ''
				echom g:cont1[lineNum]
				break
			endif
			let lineNum = lineNum-1
		endwhile
	endif
endfunction


function! JobComplete(...)
	call timer_stop(g:timer)
	call job_stop(g:jobId)
	let g:gbruhf = v:false
	execute 'call ConstantEcho()'
endfunction


function! StartTimer(...)
	let tmp = g:gbruhf
	if !tmp
		echom 'STARTED'
		let bruh = copy(a:000)
		for j in range(len(l:bruh))
			let bruh[j] = '"' . bruh[j] . '"'
		endfor
		let l:args = join(l:bruh, ' ')
		let g:jobId = job_start('cfthief -f "D:/Vim/out.txt" standings ' . l:args, {'close_cb':function('JobComplete')})
		let g:timer = timer_start(500, 'ConstantEcho', {'repeat': -1})
		let g:gbruhf = v:true
	else
		echom 'STOPPED'
		call timer_stop(g:timer)
		call job_stop(g:jobId)
		let g:gbruhf = v:false
	endif
endfunction
command! -nargs=* Thread call StartTimer(<f-args>)