chore: update format configs

.clang-format

@@ -5,11 +5,37 @@ ColumnLimit: 0
 IndentWidth: 4
 AccessModifierOffset: -2
 NamespaceIndentation: All
+AlignOperands: AlignAfterOperator
 AllowShortLoopsOnASingleLine: true
 AllowShortBlocksOnASingleLine: true
 AllowShortFunctionsOnASingleLine: Empty
 AllowShortCaseLabelsOnASingleLine: true
-AllowShortIfStatementsOnASingleLine: true
+AllowShortIfStatementsOnASingleLine: AllIfsAndElse
 EmptyLineBeforeAccessModifier: LogicalBlock
 SeparateDefinitionBlocks: Always
 PointerAlignment: Right
+BinPackArguments: false
+BinPackParameters: false
+PackConstructorInitializers: CurrentLine
+IncludeCategories:
+  - Regex: '^<ext/.*\.h>'
+    Priority: 2
+    SortPriority: 0
+    CaseSensitive: false
+  - Regex: '^<.*\.h>'
+    Priority: 1
+    SortPriority: 0
+    CaseSensitive: false
+  - Regex: '^<(iostream|cstdio)>'
+    Priority: 2
+    SortPriority: 1
+    CaseSensitive: false
+  - Regex: '^<.*'
+    Priority: 2
+    SortPriority: 0
+    CaseSensitive: false
+  - Regex: '.*'
+    Priority: 3
+    SortPriority: 0
+    CaseSensitive: false
+# InsertBraces: true   ## clang-format 15

.prettierrc

@@ -1,17 +1,36 @@
 {
-    "tabWidth": 4,
+  "tabWidth": 4,
-    "overrides": [
+  "singleQuote": true,
-        {
+  "overrides": [
-            "files": "*.md",
+    {
-            "options": {
+      "files": "*.md",
-                "tabWidth": 2
+      "options": {
-            }
+        "tabWidth": 2
-        },
+      }
-        {
+    },
-            "files": "*.y{,a}ml",
+    {
-            "options": {
+      "files": "*.y{,a}ml",
-                "tabWidth": 2
+      "options": {
-            }
+        "tabWidth": 2
-        }
+      }
-    ]
+    },
+    {
+      "files": "*.json",
+      "options": {
+        "tabWidth": 2
+      }
+    },
+    {
+      "files": ".prettierrc",
+      "options": {
+        "tabWidth": 2
+      }
+    },
+    {
+      "files": ".clang-format",
+      "options": {
+        "tabWidth": 2
+      }
+    }
+  ]
 }

AcWing/1183/1183.cpp

@@ -1,5 +1,5 @@
-#include <array>
 #include <iostream>
+#include <array>
 #include <stack>
 #include <vector>
 

AcWing/1279/1279.cpp

@@ -104,10 +104,20 @@ struct node {
     int l, r, s, d, lc, rc;
 
     node()
-        : l(0), r(0), s(0), d(0), lc(0), rc(0) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(0),
+          lc(0),
+          rc(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(0), lc(0), rc(0) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(0),
+          lc(0),
+          rc(0) {}
 } tr[N << 2];
 
 inline void pushup(int u) {

AcWing/1302/1302.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

AcWing/202/202.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <limits>
 
 using std::cin;

AcWing/2041/2041.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

AcWing/205/205.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

AcWing/207/207.cpp

@@ -1,7 +1,7 @@
+#include <iostream>
 #include <algorithm>
 #include <cmath>
 #include <iomanip>
-#include <iostream>
 
 using std::cin;
 using std::cout;

AcWing/208/208.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

AcWing/2171/2171.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <limits>
 #include <queue>
 

AcWing/2172/2172.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <queue>
 
 using std::cin;

AcWing/2173/2173.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <queue>
 
 using std::cin;

AcWing/2234/2234.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <limits>
 #include <queue>
 

AcWing/2437/2437.cpp

@@ -1,5 +1,5 @@
-#include <cstdlib>
 #include <iostream>
+#include <cstdlib>
 
 using std::cin;
 using std::cout;
@@ -14,10 +14,20 @@ struct node {
     bool d;
 
     node()
-        : l(0), r(0), s(0), v(0), d(false), k(rand()) {}
+        : l(0),
+          r(0),
+          s(0),
+          v(0),
+          d(false),
+          k(rand()) {}
 
     node(int _v)
-        : l(0), r(0), s(1), v(_v), d(false), k(rand()) {}
+        : l(0),
+          r(0),
+          s(1),
+          v(_v),
+          d(false),
+          k(rand()) {}
 } tr[N];
 
 void pushup(int u) {

AcWing/247/247.cpp

@@ -10,10 +10,16 @@ struct segment {
     int k;
 
     segment()
-        : x(0), y1(0), y2(0), k(0) {}
+        : x(0),
+          y1(0),
+          y2(0),
+          k(0) {}
 
     segment(double _x, double _y1, double _y2, int _k)
-        : x(_x), y1(_y1), y2(_y2), k(_k) {}
+        : x(_x),
+          y1(_y1),
+          y2(_y2),
+          k(_k) {}
 
     bool operator<(const segment& b) const {
         return x < b.x;
@@ -25,10 +31,16 @@ struct node {
     double len;
 
     node()
-        : l(0), r(0), cnt(0), len(0) {}
+        : l(0),
+          r(0),
+          cnt(0),
+          len(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), cnt(0), len(0) {}
+        : l(_l),
+          r(_r),
+          cnt(0),
+          len(0) {}
 } tr[10005 << 3];
 
 int find(double y) {

AcWing/252/252.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <cstring>
-#include <iostream>
 #include <vector>
 
 using std::cin;

AcWing/253/253.cpp

@@ -1,5 +1,5 @@
-#include <cstdlib>
 #include <iostream>
+#include <cstdlib>
 
 using std::cin;
 using std::cout;
@@ -45,10 +45,18 @@ struct node {
     int l, r, s, v, k;
 
     node()
-        : l(0), r(0), s(0), v(0), k(rand()) {}
+        : l(0),
+          r(0),
+          s(0),
+          v(0),
+          k(rand()) {}
 
     node(int _v)
-        : l(0), r(0), s(1), v(_v), k(rand()) {}
+        : l(0),
+          r(0),
+          s(1),
+          v(_v),
+          k(rand()) {}
 } tr[N];
 
 inline void pushup(int u) {

AcWing/255/255.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <limits>
 #include <vector>
 
@@ -52,7 +52,9 @@ struct node {
     int l, r, c;
 
     node()
-        : l(0), r(0), c(0) {}
+        : l(0),
+          r(0),
+          c(0) {}
 } tr[N << 5];
 
 int build(int l, int r) {

AcWing/2568/2568.cpp

@@ -11,10 +11,16 @@ struct node {
     long long s, d;
 
     node()
-        : l(0), r(0), s(0), d(0) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(0) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(0) {}
 } tr[100005 << 2];
 
 void dfs1(int u, int father) {

AcWing/281/281.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

AcWing/2815/2815.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;
@@ -11,10 +11,18 @@ struct node {
     int a, b, c, cnt, res;
 
     node()
-        : a(0), b(0), c(0), cnt(0), res(0) {}
+        : a(0),
+          b(0),
+          c(0),
+          cnt(0),
+          res(0) {}
 
     node(int _a, int _b, int _c)
-        : a(_a), b(_b), c(_c), cnt(1), res(0) {}
+        : a(_a),
+          b(_b),
+          c(_c),
+          cnt(1),
+          res(0) {}
 
     bool operator<(const node& x) const {
         return a == x.a ? b == x.b ? c < x.c : b < x.b : a < x.a;

AcWing/283/283.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <limits>
 
 using std::cin;

AcWing/3068/3068.cpp

@@ -10,10 +10,16 @@ struct segment {
     int x, y1, y2, k;
 
     segment()
-        : x(0), y1(0), y2(0), k(0) {}
+        : x(0),
+          y1(0),
+          y2(0),
+          k(0) {}
 
     segment(int _x, int _y1, int _y2, int _k)
-        : x(_x), y1(_y1), y2(_y2), k(_k) {}
+        : x(_x),
+          y1(_y1),
+          y2(_y2),
+          k(_k) {}
 
     bool operator<(const segment& b) const {
         return x < b.x;
@@ -25,10 +31,16 @@ struct node {
     long long cnt, len;
 
     node()
-        : l(0), r(0), cnt(0), len(0) {}
+        : l(0),
+          r(0),
+          cnt(0),
+          len(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), cnt(0), len(0) {}
+        : l(_l),
+          r(_r),
+          cnt(0),
+          len(0) {}
 } tr[100005 << 3];
 
 int find(int y) {

AcWing/381/381.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <cstdio>
+#include <algorithm>
 #include <cstring>
 #include <queue>
 

AcWing/739/739.cpp

@@ -1,5 +1,5 @@
-#include <iomanip>
 #include <iostream>
+#include <iomanip>
 
 using std::cin;
 using std::cout;

AcWing/802/802.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <vector>
 
 using std::cin;

AcWing/808/808.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

AcWing/883/883.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <cmath>
 #include <iomanip>
-#include <iostream>
 
 using std::cin;
 using std::cout;

AcWing/884/884.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <cmath>
 #include <iomanip>
-#include <iostream>
 
 using std::cin;
 using std::cout;

AcWing/899/899.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <cstring>
-#include <iostream>
 
 using std::cin;
 using std::cout;

AcWing/9/9.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <limits>
 
 using std::cin;

AcWing/902/902.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

AcWing/918/918.cpp

@@ -101,10 +101,16 @@ struct node {
     int l, r, s, d;
 
     node()
-        : l(0), r(0), s(0), d(-1) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(-1) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(-1) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(-1) {}
 } tr[N << 2];
 
 inline void pushup(int u) {

AtCoder/ABC231/A/A.cpp

@@ -1,5 +1,5 @@
-#include <iomanip>
 #include <iostream>
+#include <iomanip>
 
 using std::cin;
 using std::cout;

AtCoder/ABC231/C/C.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

AtCoder/ABC242/A/A.cpp

@@ -1,5 +1,5 @@
-#include <iomanip>
 #include <iostream>
+#include <iomanip>
 
 using std::cin;
 using std::cout;

AtCoder/ABC242/B/B.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <string>
 
 using std::cin;

AtCoder/ABC243/B/B.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

AtCoder/ABC243/D/D.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <string>
 #include <vector>
 

AtCoder/ABC245/B/B.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

AtCoder/ABC245/C/C.cpp

@@ -1,5 +1,5 @@
-#include <cmath>
 #include <iostream>
+#include <cmath>
 
 using std::cin;
 using std::cout;

AtCoder/ABC245/F/F.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <stack>
 #include <vector>
 

AtCoder/ABC246/B/B.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <cmath>
 #include <iomanip>
-#include <iostream>
 
 using std::cin;
 using std::cout;

AtCoder/ABC246/C/C.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <cmath>
-#include <iostream>
 
 using std::cin;
 using std::cout;

AtCoder/ABC246/D/D.cpp

@@ -1,5 +1,5 @@
-#include <cmath>
 #include <iostream>
+#include <cmath>
 #include <limits>
 
 using std::cin;

AtCoder/ABC251/E/E.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <cstring>
-#include <iostream>
 
 using std::cin;
 using std::cout;

BZOJ/1013/1013.cpp

@@ -1,8 +1,8 @@
 #pragma GCC optimize("Ofast")
 
+#include <cstdio>
 #include <algorithm>
 #include <cmath>
-#include <cstdio>
 
 const int N = 15;
 const double eps = 1e-6;

BZOJ/1257/1257.cpp

@@ -1,5 +1,5 @@
-#include <cmath>
 #include <iostream>
+#include <cmath>
 
 using std::cin;
 using std::cout;

BZOJ/1475/1475.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <limits>
 #include <queue>
 

BZOJ/2243/2243.cpp

@@ -104,10 +104,20 @@ struct node {
     int l, r, s, d, lc, rc;
 
     node()
-        : l(0), r(0), s(0), d(0), lc(0), rc(0) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(0),
+          lc(0),
+          rc(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(0), lc(0), rc(0) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(0),
+          lc(0),
+          rc(0) {}
 } tr[N << 2];
 
 inline void pushup(int u) {

BZOJ/2662/2662.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <queue>
 #include <vector>
 

BZOJ/2763/2763.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <cstring>
-#include <iostream>
 #include <queue>
 #include <vector>
 

BZOJ/4378/4378.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <vector>
 
 using std::cin;

Codeforces/1660/B/B.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

Codeforces/1660/C/C.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <cstring>
-#include <iostream>
 #include <string>
 
 using std::cin;

Codeforces/1661/A/A.cpp

@@ -1,5 +1,5 @@
-#include <cmath>
 #include <iostream>
+#include <cmath>
 
 using std::cin;
 using std::cout;

Codeforces/1661/B/B.cpp

@@ -1,5 +1,5 @@
-#include <cmath>
 #include <iostream>
+#include <cmath>
 #include <limits>
 
 using std::cin;

Codeforces/1661/D/D.cpp

@@ -1,5 +1,5 @@
-#include <cmath>
 #include <iostream>
+#include <cmath>
 
 using std::cin;
 using std::cout;
@@ -12,10 +12,16 @@ struct node {
     long long s, d;
 
     node()
-        : l(0), r(0), s(0), d(0) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(0) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(0) {}
 } tr[N << 2];
 
 int n, k;

Codeforces/1663/B/B.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

Codeforces/1663/G/G.js

@@ -4,18 +4,18 @@ const MIN = 32,
     MAX = 126;
 
 const SIMPLE = {
-    false: "![]",
+    false: '![]',
-    true: "!![]",
+    true: '!![]',
-    undefined: "[][[]]",
+    undefined: '[][[]]',
-    NaN: "+[![]]",
+    NaN: '+[![]]',
-    Infinity: "+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]])", // +"1e1000"
+    Infinity: '+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]])', // +"1e1000"
 };
 
 const CONSTRUCTORS = {
-    Array: "[]",
+    Array: '[]',
-    Number: "(+[])",
+    Number: '(+[])',
-    String: "([]+[])",
+    String: '([]+[])',
-    Boolean: "(![])",
+    Boolean: '(![])',
     Function: '[]["flat"]',
     RegExp: 'Function("return/"+false+"/")()',
     Object: '[]["entries"]()',
@@ -28,9 +28,9 @@ const MAPPING = {
     d: '(undefined+"")[2]',
     e: '(true+"")[3]',
     f: '(false+"")[0]',
-    g: "(false+[0]+String)[20]",
+    g: '(false+[0]+String)[20]',
     h: '(+(101))["to"+String["name"]](21)[1]',
-    i: "([false]+undefined)[10]",
+    i: '([false]+undefined)[10]',
     j: '([]["entries"]()+"")[3]',
     k: '(+(20))["to"+String["name"]](21)',
     l: '(false+"")[2]',
@@ -46,15 +46,15 @@ const MAPPING = {
     v: '(+(31))["to"+String["name"]](32)',
     w: '(+(32))["to"+String["name"]](33)',
     x: '(+(101))["to"+String["name"]](34)[1]',
-    y: "(NaN+[Infinity])[10]",
+    y: '(NaN+[Infinity])[10]',
     z: '(+(35))["to"+String["name"]](36)',
 
     A: '(NaN+[]["entries"]())[11]',
-    B: "(+[]+Boolean)[10]",
+    B: '(+[]+Boolean)[10]',
     C: 'Function("return escape")()(("")["italics"]())[2]',
     D: 'Function("return escape")()([]["flat"])["slice"]("-1")',
     E: '(RegExp+"")[12]',
-    F: "(+[]+Function)[10]",
+    F: '(+[]+Function)[10]',
     G: '(false+Function("return Date")()())[30]',
     H: null,
     I: '(Infinity+"")[0]',
@@ -63,11 +63,11 @@ const MAPPING = {
     L: null,
     M: '(true+Function("return Date")()())[30]',
     N: '(NaN+"")[0]',
-    O: "(+[]+Object)[10]",
+    O: '(+[]+Object)[10]',
     P: null,
     Q: null,
-    R: "(+[]+RegExp)[10]",
+    R: '(+[]+RegExp)[10]',
-    S: "(+[]+String)[10]",
+    S: '(+[]+String)[10]',
     T: '(NaN+Function("return Date")()())[30]',
     U: '(NaN+Object()["to"+String["name"]]["call"]())[11]',
     V: null,
@@ -76,39 +76,39 @@ const MAPPING = {
     Y: null,
     Z: null,
 
-    " ": '(NaN+[]["flat"])[11]',
+    ' ': '(NaN+[]["flat"])[11]',
-    "!": null,
+    '!': null,
     '"': '("")["fontcolor"]()[12]',
-    "#": null,
+    '#': null,
     $: null,
-    "%": 'Function("return escape")()([]["flat"])[21]',
+    '%': 'Function("return escape")()([]["flat"])[21]',
-    "&": '("")["fontcolor"](")[13]',
+    '&': '("")["fontcolor"](")[13]',
     "'": null,
-    "(": '([]["flat"]+"")[13]',
+    '(': '([]["flat"]+"")[13]',
-    ")": '([0]+false+[]["flat"])[20]',
+    ')': '([0]+false+[]["flat"])[20]',
-    "*": null,
+    '*': null,
-    "+": "(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[2]",
+    '+': '(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[2]',
-    ",": '[[]]["concat"]([[]])+""',
+    ',': '[[]]["concat"]([[]])+""',
-    "-": '(+(.+[0000001])+"")[2]',
+    '-': '(+(.+[0000001])+"")[2]',
-    ".": "(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]",
+    '.': '(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]',
-    "/": '(false+[0])["italics"]()[10]',
+    '/': '(false+[0])["italics"]()[10]',
-    ":": '(RegExp()+"")[3]',
+    ':': '(RegExp()+"")[3]',
-    ";": '("")["fontcolor"](NaN+")[21]',
+    ';': '("")["fontcolor"](NaN+")[21]',
-    "<": '("")["italics"]()[0]',
+    '<': '("")["italics"]()[0]',
-    "=": '("")["fontcolor"]()[11]',
+    '=': '("")["fontcolor"]()[11]',
-    ">": '("")["italics"]()[2]',
+    '>': '("")["italics"]()[2]',
-    "?": '(RegExp()+"")[2]',
+    '?': '(RegExp()+"")[2]',
-    "@": null,
+    '@': null,
-    "[": '([]["entries"]()+"")[0]',
+    '[': '([]["entries"]()+"")[0]',
-    "\\": '(RegExp("/")+"")[1]',
+    '\\': '(RegExp("/")+"")[1]',
-    "]": '([]["entries"]()+"")[22]',
+    ']': '([]["entries"]()+"")[22]',
-    "^": null,
+    '^': null,
     _: null,
-    "`": null,
+    '`': null,
-    "{": '(true+[]["flat"])[20]',
+    '{': '(true+[]["flat"])[20]',
-    "|": null,
+    '|': null,
-    "}": '([]["flat"]+"")["slice"]("-1")',
+    '}': '([]["flat"]+"")["slice"]("-1")',
-    "~": null,
+    '~': null,
 };
 
 const GLOBAL = 'Function("return this")()';
@@ -117,30 +117,30 @@ function fillMissingDigits() {
     var output, number, i;
 
     for (number = 0; number < 10; number++) {
-        output = "+[]";
+        output = '+[]';
 
         if (number > 0) {
-            output = "+!" + output;
+            output = '+!' + output;
         }
         for (i = 1; i < number; i++) {
-            output = "+!+[]" + output;
+            output = '+!+[]' + output;
         }
         if (number > 1) {
             output = output.substr(1);
         }
 
-        MAPPING[number] = "[" + output + "]";
+        MAPPING[number] = '[' + output + ']';
     }
 }
 
 function replaceMap() {
-    var character = "",
+    var character = '',
         value,
         i,
         key;
 
     function replace(pattern, replacement) {
-        value = value.replace(new RegExp(pattern, "gi"), replacement);
+        value = value.replace(new RegExp(pattern, 'gi'), replacement);
     }
 
     function digitReplacer(_, x) {
@@ -148,15 +148,15 @@ function replaceMap() {
     }
 
     function numberReplacer(_, y) {
-        var values = y.split("");
+        var values = y.split('');
         var head = +values.shift();
-        var output = "+[]";
+        var output = '+[]';
 
         if (head > 0) {
-            output = "+!" + output;
+            output = '+!' + output;
         }
         for (i = 1; i < head; i++) {
-            output = "+!+[]" + output;
+            output = '+!+[]' + output;
         }
         if (head > 1) {
             output = output.substr(1);
@@ -164,7 +164,7 @@ function replaceMap() {
 
         return [output]
             .concat(values)
-            .join("+")
+            .join('+')
             .replace(/(\d)/g, digitReplacer);
     }
 
@@ -176,20 +176,20 @@ function replaceMap() {
         }
 
         for (key in CONSTRUCTORS) {
-            replace("\\b" + key, CONSTRUCTORS[key] + '["constructor"]');
+            replace('\\b' + key, CONSTRUCTORS[key] + '["constructor"]');
         }
 
         for (key in SIMPLE) {
             replace(key, SIMPLE[key]);
         }
 
-        replace("(\\d\\d+)", numberReplacer);
+        replace('(\\d\\d+)', numberReplacer);
-        replace("\\((\\d)\\)", digitReplacer);
+        replace('\\((\\d)\\)', digitReplacer);
-        replace("\\[(\\d)\\]", digitReplacer);
+        replace('\\[(\\d)\\]', digitReplacer);
 
-        replace("GLOBAL", GLOBAL);
+        replace('GLOBAL', GLOBAL);
-        replace('\\+""', "+[]");
+        replace('\\+""', '+[]');
-        replace('""', "[]+[]");
+        replace('""', '[]+[]');
 
         MAPPING[character] = value;
     }
@@ -222,7 +222,7 @@ function replaceStrings() {
     }
 
     function mappingReplacer(a, b) {
-        return b.split("").join("+");
+        return b.split('').join('+');
     }
 
     function valueReplacer(c) {
@@ -248,7 +248,7 @@ function replaceStrings() {
         }
 
         if (count-- === 0) {
-            console.error("Could not compile the following chars:", missing);
+            console.error('Could not compile the following chars:', missing);
         }
     }
 }
@@ -256,32 +256,32 @@ function replaceStrings() {
 function escapeSequence(c) {
     var cc = c.charCodeAt(0);
     if (cc < 256) {
-        return "\\" + cc.toString(8);
+        return '\\' + cc.toString(8);
     } else {
         var cc16 = cc.toString(16);
-        return "\\u" + ("0000" + cc16).substring(cc16.length);
+        return '\\u' + ('0000' + cc16).substring(cc16.length);
     }
 }
 
 function escapeSequenceForReplace(c) {
-    return escapeSequence(c).replace("\\", "t");
+    return escapeSequence(c).replace('\\', 't');
 }
 
 function encode(input, wrapWithEval, runInParentScope) {
     var output = [];
 
     if (!input) {
-        return "";
+        return '';
     }
 
-    var unmappped = "";
+    var unmappped = '';
     for (var k in MAPPING) {
         if (MAPPING[k]) {
             unmappped += k;
         }
     }
-    unmappped = unmappped.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    unmappped = unmappped.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    unmappped = new RegExp("[^" + unmappped + "]", "g");
+    unmappped = new RegExp('[^' + unmappped + ']', 'g');
     var unmappedCharactersCount = (input.match(unmappped) || []).length;
     if (unmappedCharactersCount > 1) {
         // Without this optimization one unmapped caracter has encoded length
@@ -316,91 +316,91 @@ function encode(input, wrapWithEval, runInParentScope) {
         input = input.replace(unmappped, escapeSequence);
     }
 
-    var r = "";
+    var r = '';
     for (var i in SIMPLE) {
-        r += i + "|";
+        r += i + '|';
     }
-    r += ".";
+    r += '.';
 
-    input.replace(new RegExp(r, "g"), function (c) {
+    input.replace(new RegExp(r, 'g'), function (c) {
         var replacement = SIMPLE[c];
         if (replacement) {
-            output.push("(" + replacement + "+[])");
+            output.push('(' + replacement + '+[])');
         } else {
             replacement = MAPPING[c];
             if (replacement) {
                 output.push(replacement);
             } else {
-                throw new Error("Found unmapped character: " + c);
+                throw new Error('Found unmapped character: ' + c);
             }
         }
     });
 
-    output = output.join("+");
+    output = output.join('+');
 
     if (/^\d$/.test(input)) {
-        output += "+[]";
+        output += '+[]';
     }
 
     if (unmappedCharactersCount > 1) {
         // replace `t` with `\\`
         output =
-            "(" +
+            '(' +
             output +
-            ")[" +
+            ')[' +
-            encode("split") +
+            encode('split') +
-            "](" +
+            '](' +
-            encode("t") +
+            encode('t') +
-            ")[" +
+            ')[' +
-            encode("join") +
+            encode('join') +
-            "](" +
+            '](' +
-            encode("\\") +
+            encode('\\') +
-            ")";
+            ')';
     }
 
     if (unmappedCharactersCount > 0) {
         output =
-            "[][" +
+            '[][' +
-            encode("flat") +
+            encode('flat') +
-            "]" +
+            ']' +
-            "[" +
+            '[' +
-            encode("constructor") +
+            encode('constructor') +
-            "]" +
+            ']' +
-            "(" +
+            '(' +
             encode('return"') +
-            "+" +
+            '+' +
             output +
-            "+" +
+            '+' +
             encode('"') +
-            ")()";
+            ')()';
     }
 
     if (wrapWithEval) {
         if (runInParentScope) {
             output =
-                "[][" +
+                '[][' +
-                encode("flat") +
+                encode('flat') +
-                "]" +
+                ']' +
-                "[" +
+                '[' +
-                encode("constructor") +
+                encode('constructor') +
-                "]" +
+                ']' +
-                "(" +
+                '(' +
-                encode("return eval") +
+                encode('return eval') +
-                ")()" +
+                ')()' +
-                "(" +
+                '(' +
                 output +
-                ")";
+                ')';
         } else {
             output =
-                "[][" +
+                '[][' +
-                encode("flat") +
+                encode('flat') +
-                "]" +
+                ']' +
-                "[" +
+                '[' +
-                encode("constructor") +
+                encode('constructor') +
-                "]" +
+                ']' +
-                "(" +
+                '(' +
                 output +
-                ")()";
+                ')()';
         }
     }
 

Codeforces/1675/B/B.cpp

@@ -1,5 +1,5 @@
-#include <cmath>
 #include <iostream>
+#include <cmath>
 #include <limits>
 
 using std::cin;

Codeforces/1678/A/A.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

Codeforces/1679/A/A.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

Codeforces/1681/C/C.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <vector>
 
 using std::cin;

Codeforces/1681/D/D.cpp

@@ -1,7 +1,7 @@
 #pragma GCC optimize("Ofast")
 
-#include <cmath>
 #include <iostream>
+#include <cmath>
 #include <map>
 #include <string>
 #include <vector>

Codeforces/1682/B/B.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 
 using std::cin;
 using std::cout;

Codeforces/1682/C/C.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <cmath>
-#include <iostream>
 
 using std::cin;
 using std::cout;

Gym/103081/I/I.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <cmath>
 #include <cstring>
-#include <iostream>
 #include <queue>
 #include <vector>
 

Gym/103427/H/H.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

Gym/103698/C/C.cpp

@@ -1,6 +1,6 @@
+#include <iostream>
 #include <algorithm>
 #include <iomanip>
-#include <iostream>
 
 using std::cin;
 using std::cout;

Hydro/system/H1005/H1005.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

LibreOJ/100/100.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

LibreOJ/101/101.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <limits>
 #include <queue>
 

LibreOJ/10138/10138.cpp

@@ -106,10 +106,16 @@ struct node {
     int l, r, sum, max;
 
     node()
-        : l(0), r(0), sum(0), max(numeric_limits<int>::min()) {}
+        : l(0),
+          r(0),
+          sum(0),
+          max(numeric_limits<int>::min()) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), sum(0), max(numeric_limits<int>::min()) {}
+        : l(_l),
+          r(_r),
+          sum(0),
+          max(numeric_limits<int>::min()) {}
 } tr[N << 2];
 
 void pushup(int u) {

LibreOJ/10141/10141.cpp

@@ -104,10 +104,20 @@ struct node {
     int l, r, s, d, lc, rc;
 
     node()
-        : l(0), r(0), s(0), d(0), lc(0), rc(0) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(0),
+          lc(0),
+          rc(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(0), lc(0), rc(0) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(0),
+          lc(0),
+          rc(0) {}
 } tr[N << 2];
 
 inline void pushup(int u) {

LibreOJ/10145/10145.cpp

@@ -17,10 +17,18 @@ struct node {
     int l, r, s, v, k;
 
     node()
-        : l(0), r(0), s(0), v(0), k(rand()) {}
+        : l(0),
+          r(0),
+          s(0),
+          v(0),
+          k(rand()) {}
 
     node(int _v)
-        : l(0), r(0), s(1), v(_v), k(rand()) {}
+        : l(0),
+          r(0),
+          s(1),
+          v(_v),
+          k(rand()) {}
 } tr[N];
 
 void pushup(int u) {

LibreOJ/10173/10173.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 
 using std::cin;
 using std::cout;

LibreOJ/102/102.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <limits>
 #include <queue>
 

LibreOJ/10215/10215.cpp

@@ -1,5 +1,5 @@
-#include <algorithm>
 #include <iostream>
+#include <algorithm>
 #include <tuple>
 
 using std::cin;

LibreOJ/104/104.cpp

@@ -1,5 +1,5 @@
-#include <cstdlib>
 #include <iostream>
+#include <cstdlib>
 
 using std::cin;
 using std::cout;
@@ -14,10 +14,18 @@ class Treap {
         int size, val, key;
 
         node()
-            : left(nullptr), right(nullptr), size(1), val(0), key(rand()) {}
+            : left(nullptr),
+              right(nullptr),
+              size(1),
+              val(0),
+              key(rand()) {}
 
         node(int _val)
-            : left(nullptr), right(nullptr), size(1), val(_val), key(rand()) {}
+            : left(nullptr),
+              right(nullptr),
+              size(1),
+              val(_val),
+              key(rand()) {}
 
         ~node() {
             delete left, right;

LibreOJ/105/105.cpp

@@ -1,5 +1,5 @@
-#include <cstdlib>
 #include <iostream>
+#include <cstdlib>
 
 using std::cin;
 using std::cout;
@@ -14,10 +14,20 @@ struct node {
     bool d;
 
     node()
-        : l(0), r(0), s(0), v(0), d(false), k(rand()) {}
+        : l(0),
+          r(0),
+          s(0),
+          v(0),
+          d(false),
+          k(rand()) {}
 
     node(int _v)
-        : l(0), r(0), s(1), v(_v), d(false), k(rand()) {}
+        : l(0),
+          r(0),
+          s(1),
+          v(_v),
+          d(false),
+          k(rand()) {}
 } tr[N];
 
 void pushup(int u) {

LibreOJ/2054/2054.cpp

@@ -93,10 +93,14 @@ struct node {
     int l, r, d;
 
     node()
-        : l(0), r(0), d(-1) {}
+        : l(0),
+          r(0),
+          d(-1) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), d(-1) {}
+        : l(_l),
+          r(_r),
+          d(-1) {}
 } tr[N << 2];
 
 inline void pushup(int u) {

LibreOJ/2125/2125.cpp

@@ -113,10 +113,16 @@ struct node {
     long long s, d;
 
     node()
-        : l(0), r(0), s(0), d(0) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(0) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(0) {}
 } tr[N << 2];
 
 inline void pushup(int u) {

LibreOJ/2130/2130.cpp

@@ -101,10 +101,16 @@ struct node {
     int l, r, s, d;
 
     node()
-        : l(0), r(0), s(0), d(-1) {}
+        : l(0),
+          r(0),
+          s(0),
+          d(-1) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), s(0), d(-1) {}
+        : l(_l),
+          r(_r),
+          s(0),
+          d(-1) {}
 } tr[N << 2];
 
 inline void pushup(int u) {

LibreOJ/2279/2279.cpp

@@ -6,10 +6,14 @@ struct node {
     int l, r, max;
 
     node()
-        : l(0), r(0), max(0) {}
+        : l(0),
+          r(0),
+          max(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), max(0) {}
+        : l(_l),
+          r(_r),
+          max(0) {}
 } tr[50005 << 2];
 
 int n, m, x, y, a[50005];

LibreOJ/2606/2606.cpp

@@ -39,10 +39,16 @@ struct node {
     int l, r, m, d;
 
     node()
-        : l(0), r(0), m(std::numeric_limits<int>::max()), d(0) {}
+        : l(0),
+          r(0),
+          m(std::numeric_limits<int>::max()),
+          d(0) {}
 
     node(int _l, int _r)
-        : l(_l), r(_r), m(std::numeric_limits<int>::max()), d(0) {}
+        : l(_l),
+          r(_r),
+          m(std::numeric_limits<int>::max()),
+          d(0) {}
 } tr[1000005 << 1];
 
 void pushup(int u) {

LibreOJ/2633/2633.cpp

@@ -13,19 +13,29 @@ struct node {
     int x, y, step;
 
     node()
-        : x(0), y(0), step(0) {}
+        : x(0),
+          y(0),
+          step(0) {}
 
     node(int _x, int _y)
-        : x(_x), y(_y), step(0) {}
+        : x(_x),
+          y(_y),
+          step(0) {}
 
     node(pair<int, int> _point)
-        : x(_point.first), y(_point.second), step(0) {}
+        : x(_point.first),
+          y(_point.second),
+          step(0) {}
 
     node(pair<int, int> _point, int _step)
-        : x(_point.first), y(_point.second), step(_step) {}
+        : x(_point.first),
+          y(_point.second),
+          step(_step) {}
 
     node(int _x, int _y, int _step)
-        : x(_x), y(_y), step(_step) {}
+        : x(_x),
+          y(_y),
+          step(_step) {}
 };
 
 /**

LibreOJ/2759/2759.cpp

@@ -1,5 +1,5 @@
-#include <cstring>
 #include <iostream>
+#include <cstring>
 #include <queue>
 #include <vector>