├── C++14_linux.sublime-build ├── C++14_os_x.sublime-build ├── C++14_windows.sublime-build ├── README.md └── template.cpp /C++14_linux.sublime-build: -------------------------------------------------------------------------------- 1 | { 2 | "cmd" : ["g++ -std=c++14 $file_name -o $file_base_name && timeout 4s ./$file_base_nameoutputf.in"], 3 | "selector" : "source.c", 4 | "shell": true, 5 | "working_dir" : "$file_path" 6 | } 7 | -------------------------------------------------------------------------------- /C++14_os_x.sublime-build: -------------------------------------------------------------------------------- 1 | { 2 | "cmd" : ["g++-10 $file_name -o $file_base_name && gtimeout 4s ./$file_base_nameoutputf.in"], 3 | "selector" : "source.c", 4 | "shell": true, 5 | "working_dir" : "$file_path" 6 | } 7 | -------------------------------------------------------------------------------- /C++14_windows.sublime-build: -------------------------------------------------------------------------------- 1 | { 2 | "cmd": ["g++.exe","-std=c++14", "${file}", "-o", "${file_base_name}.exe", "&&" , "${file_base_name}.exeoutputf.in"], 3 | "selector":"source.cpp", 4 | "shell":true, 5 | "working_dir":"$file_path" 6 | } 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Competitive-Programming 2 | 3 | ## Template.cpp : 4 | c++ codes for various functions 5 | 6 | 7 | ## C++14.sublime-build (FOR LINUX) : 8 | 9 | Build system to directly compile and run c++ programs in sublime on linux. Moreover it uses c++14 directly opposed to the fact that terminal doesnt. 10 | 11 | ***Instructions :*** 12 | * Go to Tools > Build Systems > New Build System 13 | * Copy the code from C++14.sublime-build and paste it ther and save it by any name. 14 | * Go to Tools > Build Systems ans select your new build system 15 | * Create 2 files named inputf.in and outputf.in in same directory in which u have ur code. 16 | * Write input in inputf.in, save and run the code in sublime and you will get output in outputf.in . 17 | 18 | ***Tips :*** 19 | * You can use CTRL + shift + B to directly compile run. 20 | * You can use 3 pane setup to view code, input dile and output file at once (ALT + SHIFT + 3). 21 | 22 | ## C++14.sublime-build (FOR OS X(Mac Users) ) : 23 | 24 | Follow the same steps above just copy the sublime build file corresponding to OS X. You need to have gcc and gtimout installed to be able to run above build system. 25 | 26 | To install gcc in OS X : 27 | ``` 28 | brew install gcc 29 | ``` 30 | To install gtimout in OS X : 31 | ``` 32 | brew install coreutils 33 | ``` 34 | Remember you may have to change the version in g++-{version} in sublime build file according to gcc version installed by brew. At the time of writting this post it is 10 hence is written as g++-9 35 | 36 | ***This is how it looks*** 37 | 38 | ![screenshot from 2017-04-04 05-35-27](https://cloud.githubusercontent.com/assets/11024840/24636899/0511b208-18fb-11e7-88d5-6cf4b810370b.png "Sublime Build Sytem - C++14") 39 | -------------------------------------------------------------------------------- /template.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define ll long long 3 | #define ull unsigned long long int 4 | #define pb push_back 5 | #define mp make_pair 6 | #define fi first 7 | #define se second 8 | #define p(x) printf("%d\n", x) 9 | #define pl(x) printf("%lld\n", x) 10 | #define s(x) scanf("%d", &x) 11 | #define sl(x) scanf("%lld", &x) 12 | #define sf(x) scanf("%lf", &x) 13 | #define bitcount __builtin_popcountll 14 | #define INF 1e18+9 15 | #define endl '\n' 16 | #define FIO ios_base::sync_with_stdio(false) 17 | using namespace std; 18 | #define M 1000000007 19 | #define MAX 1000001 20 | #define trace1(x) cerr<<#x<<": "< 51 | void __print(const pair &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';} 52 | template 53 | void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";} 54 | void _print() {cerr << "]\n";} 55 | template 56 | void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);} 57 | #ifndef ONLINE_JUDGE 58 | #define debug(x...) cerr << "[" << #x << "] = ["; _print(x) 59 | #else 60 | #define debug(x...) 61 | #endif 62 | 63 | 64 | time spent(){ 65 | clock_t begin = clock(); 66 | // CODE 67 | clock_t end = clock(); 68 | double time_spent = (double)(end - begin) / CLOCKS_PER_SEC; 69 | } 70 | 71 | void ss(string &i){ 72 | int temp=getchar_unlocked(); 73 | while((temp < 'a' || temp > 'z') && (temp < 'A' || temp > 'Z')) 74 | temp=getchar_unlocked(); 75 | while((temp >= 'a' && temp <= 'z') || (temp >= 'A' && temp <= 'Z')){ 76 | i.pb((char)temp); 77 | temp = getchar_unlocked(); 78 | } 79 | } 80 | void write(int &x){ 81 | register char buffor[35]; 82 | register int i=0; 83 | do{ 84 | buffor[i++]=(x%10)+'0'; 85 | x/=10; 86 | } while(x); 87 | i--; 88 | while(i>=0) putchar_unlocked(buffor[i--]); 89 | putchar_unlocked('\n'); 90 | } 91 | void fs(int &x){ 92 | register int c = getchar_unlocked(); 93 | x = 0; 94 | for(; (c<48 || c>57); c = getchar_unlocked()); 95 | for(; c>47 && c<58; c = getchar_unlocked()){ 96 | x = (x<<1) + (x<<3) + c - 48; 97 | } 98 | } 99 | void fs(long long &x){ 100 | register long long c = getchar_unlocked(); 101 | x = 0; 102 | for(; (c<48 || c>57); c = getchar_unlocked()); 103 | for(; c>47 && c<58; c = getchar_unlocked()){ 104 | x = (x<<1) + (x<<3) + c - 48; 105 | } 106 | } 107 | 108 | bool cmp(node a, node b){ 109 | if(a.x != b.x){ 110 | return (a.x < b.x); 111 | } 112 | else{ 113 | return (a.y > b.y); 114 | } 115 | } 116 | 117 | ll divide(string s, ll x){ 118 | vector a; 119 | for(int i = 0; i < s.size(); ++i){ 120 | a.pb((ll)s[i] - '0'); 121 | } 122 | ll temp = 0; 123 | for(int i = 0; i < a.size(); ++i){ 124 | temp = temp *10 + a[i]; 125 | if(temp >= x){ 126 | temp %= x; 127 | } 128 | } 129 | return temp; 130 | } 131 | 132 | 133 | 134 | int binexp1(int a, int b, int m){ 135 | int result = 1; 136 | while(b>0){ 137 | if(b & 1){ 138 | result = (result * 1LL * a) % m; 139 | } 140 | a = (a * 1LL * a) % m; 141 | b >>= 1; 142 | } 143 | return result; 144 | } 145 | 146 | long long multiply(long long a, long long b, long long m){ 147 | long long result = 0; 148 | while(b>0){ 149 | if(b & 1){ 150 | result = result + a; 151 | result %= m; 152 | } 153 | a <<= 1; 154 | a %= m; 155 | b >>= 1; 156 | } 157 | return result; 158 | } 159 | 160 | long long binexp2(long long a, long long b, long long m){ 161 | long long result = 1; 162 | while(b>0){ 163 | if(b & 1){ 164 | result = multiply(result, a, m); 165 | } 166 | a = multiply(a, a, m); 167 | b >>= 1; 168 | } 169 | return result; 170 | } 171 | 172 | void sieve(){ 173 | for(int i = 2; i < 10000001; ++i){ 174 | if(isprime[i] == 0){ 175 | for(int j = 2; i*j < 10000001; ++j){ 176 | isprime[i*j] = 1; 177 | } 178 | } 179 | } 180 | } 181 | 182 | void etf(){ 183 | for(int i=0; i < 10000001; ++i) 184 | phi[i] = i; 185 | for(int i=2; i < 10000001; ++i){ 186 | if(phi[i] == i ){ 187 | for(int j=1; i*j < 10000001; ++j){ 188 | phi[i*j] /= i; 189 | phi[i*j] *= (i-1); 190 | } 191 | } 192 | } 193 | } 194 | 195 | 196 | // miller rabin 197 | 198 | bool miller(long long n){ 199 | if(n <=1 || n % 2 == 0){ 200 | if(n != 2){ 201 | return false; 202 | } 203 | } 204 | if(n == 2 || n == 3){ 205 | return true; 206 | } 207 | long long d = n-1; 208 | while(d % 2 == 0){ 209 | d /= 2; 210 | } 211 | long long a[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}; 212 | for(int i = 0; i < 12 && a[i] < n; ++i){ 213 | long long temp = d; 214 | long long mod = binexp2(a[i], temp, n); 215 | if(mod == 1){ 216 | continue; 217 | } 218 | while(temp != n-1 && mod != n-1){ 219 | mod = multiply(mod, mod, n); 220 | temp *= 2; 221 | 222 | } 223 | if(mod != n-1){ 224 | return false; 225 | } 226 | } 227 | return true; 228 | } 229 | 230 | // extendid euclid 231 | 232 | struct node{ 233 | ll x, y; 234 | }; 235 | struct node exteuclid(ll a, ll b){ 236 | if(a % b == 0){ 237 | node ret; 238 | ret.x = 0; 239 | ret.y = 1; 240 | return ret; 241 | } 242 | node ans = exteuclid(b, a % b); 243 | node ret; 244 | ret.x = ans.y; 245 | ret.y = ans.x - (a / b) * ans.y; 246 | return ret; 247 | } 248 | 249 | // binary indexed tree 250 | 251 | void update(int i, int x){ 252 | while(i <= N){ 253 | bit[i] += x; 254 | i = i + (i & (-i)); 255 | } 256 | } 257 | 258 | int sum(int i){ 259 | int ans = 0; 260 | while(i != 0 && i > 0){ 261 | ans += bit[i]; 262 | i = (i & (i-1)); 263 | } 264 | return ans; 265 | } 266 | 267 | void rupdate(int a, int b, int val){ 268 | update(a, val, bit1); 269 | update(b + 1, -val, bit1); 270 | update(a, val * (a-1), bit2); 271 | update(b + 1, -val * b, bit2); 272 | } 273 | 274 | ll rsum(int i){ 275 | return sum(i, bit1) * i - sum(i, bit2); 276 | } 277 | 278 | void update(int i, int j, int val){ 279 | int y1; 280 | while (i <= N){ 281 | y1 = j; 282 | while (y1 <= N){ 283 | bit[i][y1] += val; 284 | y1 += (y1 & (-y1)); 285 | } 286 | i += (i & -i); 287 | } 288 | } 289 | 290 | int sum(int i,int j){ 291 | int sum= 0; 292 | while(i){ 293 | int y1 = j; 294 | while(y1){ 295 | sum += bit[i][y1]; 296 | y1 -= (y1 & (-y1)); 297 | } 298 | i -= (i & (-i)); 299 | } 300 | return sum; 301 | } 302 | 303 | // segment tree 304 | 305 | void build(int a[], int v, int tl, int tr){ 306 | if(tl == tr){ 307 | t[v] = a[tl]; 308 | } 309 | else{ 310 | int tm = (tl+tr) >> 1; 311 | build(a, v << 1, tl, tm); 312 | build(a, (v << 1)+1, tm+1, tr); 313 | t[v] = t[v << 1] + t[(v << 1) + 1]; 314 | } 315 | } 316 | ll sum(int v, int tl, int tr, int l, int r){ 317 | if(l > r){ 318 | return 0; 319 | } 320 | if(tl == l && tr == r){ 321 | return t[v]; 322 | } 323 | int tm = (tl + tr) >> 1; 324 | return sum(v << 1, tl, tm, l, min(tm, r)) + sum((v << 1)+1, tm + 1, tr, max(l, tm+1), r); 325 | } 326 | void update(int v, int tl, int tr, int pos, int val){ 327 | if(tl == tr){ 328 | t[v] = val; 329 | } 330 | else{ 331 | int tm = (tl+tr) >> 1; 332 | if(pos <= tm){ 333 | update(v << 1, tl, tm, pos, val); 334 | } 335 | else{ 336 | update((v << 1) + 1, tm+1, tr, pos, val); 337 | } 338 | t[v] = t[v << 1] + t[(v << 1)+1]; 339 | } 340 | } 341 | //lazy propagation 342 | 343 | void build(int v, int tl, int tr){ 344 | lazy[v] = 0; 345 | if(tl == tr){ 346 | t[v] = 1LL<> 1; 350 | build(v<<1, tl, mid); 351 | build((v<<1) + 1, mid+1, tr); 352 | t[v] = t[v<<1] | t[(v<<1) + 1]; 353 | } 354 | } 355 | 356 | void update(int v, int tl, int tr, int l, int r, long long val){ 357 | if(lazy[v]){ 358 | if(tl == tr){ 359 | t[v] = lazy[v]; 360 | } 361 | else{ 362 | t[v] = lazy[v]; 363 | lazy[v<<1] = lazy[v]; 364 | lazy[(v<<1) + 1] = lazy[v]; 365 | } 366 | lazy[v] = 0; 367 | } 368 | if(tl > r || tr < l) 369 | return; 370 | if(l <= tl && r >= tr){ 371 | if(tl == tr){ 372 | t[v] = (1LL << val); 373 | } 374 | else{ 375 | t[v] = (1LL << val); 376 | lazy[v<<1] = (1LL<> 1; 382 | update(v<<1, tl, mid, l, r, val); 383 | update((v<<1) + 1, mid + 1, tr, l, r, val); 384 | t[v] = t[v<<1] | t[(v<<1) + 1]; 385 | } 386 | 387 | long long qry(int v, int tl, int tr, int l, int r){ 388 | if(lazy[v]){ 389 | if(tl == tr) 390 | t[v] = lazy[v]; 391 | else{ 392 | t[v] = lazy[v]; 393 | lazy[v<<1] = lazy[v]; 394 | lazy[(v<<1) + 1] = lazy[v]; 395 | } 396 | lazy[v] = 0; 397 | } 398 | if(tr < l or tl > r) 399 | return 0LL; 400 | if(tl>=l and tr<=r){ 401 | return t[v]; 402 | } 403 | int mid = (tl + tr) >> 1; 404 | return qry(v << 1, tl, mid, l, r) + qry((v<<1) + 1, mid + 1, tr, l, r); 405 | } 406 | 407 | 408 | // DSU 409 | 410 | int parent[N], rnk[N]; 411 | 412 | void make(int v){ 413 | parent[v] = v; 414 | rnk[v] = 0; 415 | } 416 | 417 | int find(int v){ 418 | if(parent[v] != v) 419 | parent[v] = find(parent[v]); 420 | return parent[v]; 421 | } 422 | 423 | void Union(int a, int b){ 424 | a = find(a); 425 | b = find(b); 426 | if(a != b){ 427 | if(rnk[a] < rnk[b]) 428 | swap(a, b); 429 | parent[b] = a; 430 | if(rnk[a] == rnk[b]) 431 | rnk[a]++; 432 | } 433 | } 434 | 435 | // MST 436 | void merge(int v, int vl, int vr){ 437 | int i = 0, j = 0; 438 | for(i = 0, j = 0; i < t[vl].size() && j < t[vr].size();){ 439 | if(t[vl][i] <= t[vr][j]){ 440 | t[v].pb(t[vl][i]); 441 | ++i; 442 | } 443 | else{ 444 | t[v].pb(t[vr][j]); 445 | ++j; 446 | } 447 | } 448 | while(i < t[vl].size()){ 449 | t[v].pb(t[vl][i]); 450 | ++i; 451 | } 452 | while(j < t[vr].size()){ 453 | t[v].pb(t[vr][j]); 454 | ++j; 455 | } 456 | } 457 | void build(int v, int tl, int tr){ 458 | if(tl == tr){ 459 | t[v].pb(a[tl]); 460 | } 461 | else{ 462 | int tm = (tl+tr) >> 1; 463 | build(v << 1, tl, tm); 464 | build((v << 1)+1, tm+1, tr); 465 | merge(v, v << 1, (v << 1) + 1); 466 | } 467 | } 468 | int qry(int v, int tl, int tr, int l, int r, int k){ 469 | if(l > r){ 470 | return 0; 471 | } 472 | if(tl == l && tr == r){ 473 | auto it = upper_bound(t[v].begin(), t[v].end(), k); 474 | return (t[v].end()-it); 475 | } 476 | int tm = (tl + tr) >> 1; 477 | return qry(v << 1, tl, tm, l, min(tm, r), k) + qry((v << 1)+1, tm + 1, tr, max(l, tm+1), r, k); 478 | } 479 | 480 | // LCA 481 | #define MLOG 18 482 | int parent[MAX][MLOG], level[MAX], tin[MAX], tout[MAX], timer, vis[MAX]; 483 | vector g[MAX]; 484 | void dfs(int node){ 485 | vis[node] = 1; 486 | tin[node] = ++timer; 487 | for(int i : g[node]){ 488 | if(vis[i] == 0){ 489 | parent[i][0] = node; 490 | level[i] = level[node]+1; 491 | dfs(i); 492 | } 493 | } 494 | tout[node] = ++timer; 495 | } 496 | void setparent(int n){ 497 | for(int i = 1 ; i < MLOG ; ++i){ 498 | for(int j = 1 ; j <= n; ++j){ 499 | parent[j][i] = parent[parent[j][i-1]][i-1]; 500 | } 501 | } 502 | } 503 | bool isanc(int top, int bot){ 504 | return (tin[top] <= tin[bot]) && (tout[bot] <= tout[top]); 505 | } 506 | int lca(int a, int b){ 507 | int diff = level[a] - level[b]; 508 | if(diff < 0){ 509 | swap(a, b); 510 | diff *= -1; 511 | } 512 | for(int i = 0; i < MLOG; ++i){ 513 | if(diff & (1LL<= 0; --i){ 519 | if(parent[a][i] != parent[b][i]){ 520 | a = parent[a][i]; 521 | b = parent[b][i]; 522 | } 523 | } 524 | a = parent[a][0]; 525 | } 526 | return a; 527 | } 528 | int dist(int a , int b){ 529 | return level[a] + level[b] - 2 * level[lca(a , b)]; 530 | } 531 | 532 | // MATRIX EXPO 533 | 534 | void matmul(ll a[3][3], ll b[3][3], ll c[3][3]){ 535 | int i, j, k; 536 | for(i = 0; i < 3; ++i){ 537 | for(j = 0; j < 3; ++j){ 538 | c[i][j] = 0; 539 | for(k = 0; k < 3; ++k){ 540 | c[i][j] += (a[i][k]*b[k][j];) % M; 541 | c[i][j] %= M; 542 | } 543 | } 544 | } 545 | } 546 | 547 | void matexp(ll a[3][3], ll b, ll ans[3][3]){ 548 | int i, j; 549 | ll tmp[3][3]; 550 | for(i = 0; i < 3; ++i){ 551 | for(j = 0; j < 3; ++j){ 552 | if(i == j){ 553 | ans[i][j] = 1; 554 | } 555 | else{ 556 | ans[i][j] = 0; 557 | } 558 | } 559 | } 560 | while(b > 0){ 561 | if(b&1){ 562 | matmul(ans, a, tmp); 563 | for(i = 0; i < 3; ++i) 564 | for(j = 0; j < 3; ++j) 565 | ans[i][j] = tmp[i][j]; 566 | } 567 | matmul(a, a, tmp); 568 | for(i = 0; i < 3; ++i) 569 | for(j = 0; j < 3; ++j) 570 | a[i][j] = tmp[i][j]; 571 | b >>= 1; 572 | } 573 | } 574 | 575 | // KMP 576 | void LPS(string &p){ 577 | lps[0] = 0; 578 | int i = 1, j = 0; 579 | while(i < p.size()){ 580 | if(p[i] == p[j]){ 581 | j++; 582 | lps[i] = j; 583 | i++; 584 | } 585 | else if(j > 0){ 586 | j = lps[j-1]; 587 | } 588 | else{ 589 | lps[i] = 0; 590 | i++; 591 | } 592 | } 593 | } 594 | 595 | // Z - Algorithm 596 | void getZarr(string &str){ 597 | int n = str.length(); 598 | int L, R, k; 599 | L = R = 0; 600 | for(int i = 1; i < n; ++i){ 601 | if (i > R){ 602 | L = R = i; 603 | while (R 0); 651 | } 652 | }tr; 653 | 654 | //Dinics max flow ALGO 655 | struct edge{ 656 | int from, to, cap, flow; 657 | }; 658 | vector g[MAX]; 659 | vector e; 660 | int source, sink, level[MAX], ptr[MAX]; 661 | 662 | void add_edge(int from, int to, int cap){ 663 | edge e1 = {from, to, cap, 0}; 664 | edge e2 = {to, from, 0, 0}; 665 | g[from].push_back(e.size()); 666 | e.push_back(e1); 667 | g[to].push_back(e.size()); 668 | e.push_back(e2); 669 | } 670 | 671 | int bfs(){ 672 | memset(level, -1, sizeof(level)); 673 | level[source] = 0; 674 | queue q; 675 | q.push(source); 676 | int v; 677 | while(!q.empty()){ 678 | v = q.front(); 679 | q.pop(); 680 | if(v == sink){ 681 | return 1; 682 | } 683 | for(auto i : g[v]){ 684 | int to = e[i].to; 685 | if(level[to] == -1 && e[i].flow < e[i].cap){ 686 | level[to] = level[v] + 1; 687 | q.push(to); 688 | } 689 | } 690 | } 691 | return 0; 692 | } 693 | 694 | int dfs(int v, int flow){ 695 | if(flow <= 0) 696 | return 0; 697 | if(v == sink) 698 | return flow; 699 | for(; ptr[v] < g[v].size(); ++ptr[v]){ 700 | int id = g[v][ptr[v]], to = e[id].to; 701 | if(level[to] != level[v] + 1) 702 | continue; 703 | int pushed = dfs(to, min(flow, e[id].cap - e[id].flow)); 704 | if(pushed){ 705 | e[id].flow += pushed; 706 | e[id^1].flow -= pushed; 707 | return pushed; 708 | } 709 | } 710 | return 0; 711 | } 712 | int dinic(){ 713 | int flow = 0, val; 714 | while(bfs()){ 715 | memset(ptr, 0, sizeof(ptr)); 716 | while(val = dfs(source, INF)){ 717 | flow += val; 718 | } 719 | } 720 | return flow; 721 | } 722 | 723 | // MO's 724 | int block, n; 725 | 726 | struct node{ 727 | int l, r, idx; 728 | long long ans; 729 | }qry[N]; 730 | bool cmp(node a, node b){ 731 | if((a.l / block) != b.l / block) 732 | return (a.l / block) < (b.l/block); 733 | else 734 | return (a.r < b.r); 735 | } 736 | 737 | bool cmp1(node a, node b){ 738 | return (a.idx < b.idx); 739 | } 740 | int ans; 741 | void add(int val){ 742 | //update 743 | } 744 | void remove(int val){ 745 | //deupdate 746 | } 747 | int main(){ 748 | sort(qry, qry + q, cmp); 749 | for(int i = qry[0].l; i <= qry[0].r; ++i){ 750 | add(a[i]); 751 | } 752 | int curr, curl; 753 | qry[0].ans = ans; 754 | curl = qry[0].l; 755 | curr = qry[0].r; 756 | for(int i = 1; i < q; ++i){ 757 | while(curl < qry[i].l){ 758 | remove(a[curl++]); 759 | } 760 | while(curr < qry[i].r){ 761 | add(a[++curr]); 762 | } 763 | while(curl > qry[i].l){ 764 | add(a[--curl]); 765 | } 766 | while(curr > qry[i].r){ 767 | remove(a[curr--]); 768 | } 769 | qry[i].ans = ans; 770 | } 771 | sort(qry, qry + q, cmp1); 772 | for(int i = 0; i < q; ++i){ 773 | printf("%lld\n", qry[i].ans); 774 | } 775 | } 776 | 777 | //ordered Set | policy based data structure 778 | 779 | #include 780 | #include 781 | #include 782 | 783 | using namespace __gnu_pbds; 784 | using namespace std; 785 | 786 | typedef tree, rb_tree_tag, tree_order_statistics_node_update> ordered_set; 787 | 788 | 789 | int main(){ 790 | ordered_set X; 791 | X.insert(1); 792 | X.insert(2); 793 | X.insert(4); 794 | X.insert(8); 795 | X.insert(16); 796 | cout<<*X.find_by_order(1)<