From c8bcb2f4f7b295b232e8f88abfbb46402d50f701 Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Thu, 29 Oct 2020 13:39:47 +0900
Subject: [PATCH 01/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 arc017/a/main.py        | 46 ++++++++++++++++++++++++++++++++
 arc017/b/main.py        | 46 ++++++++++++++++++++++++++++++++
 arc017/c/main.py        | 59 +++++++++++++++++++++++++++++++++++++++++
 arc017/contest.acc.json | 53 ++++++++++++++++++++++++++++++++++++
 arc017/d/main.py        | 46 ++++++++++++++++++++++++++++++++
 5 files changed, 250 insertions(+)
 create mode 100644 arc017/a/main.py
 create mode 100644 arc017/b/main.py
 create mode 100644 arc017/c/main.py
 create mode 100644 arc017/contest.acc.json
 create mode 100644 arc017/d/main.py

diff --git a/arc017/a/main.py b/arc017/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/arc017/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/arc017/b/main.py b/arc017/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/arc017/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/arc017/c/main.py b/arc017/c/main.py
new file mode 100644
index 0000000..6f906ce
--- /dev/null
+++ b/arc017/c/main.py
@@ -0,0 +1,59 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N, X = LI()
+    W = IR(N)
+
+    first, second = W[:N//2], W[N//2:]
+    d = defaultdict(int)
+
+    for s in powerset(first):
+        d[sum(s)] += 1
+
+    ans = 0
+    for s in powerset(second):
+        ans += d[X - sum(s)]
+    print(ans)
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/arc017/contest.acc.json b/arc017/contest.acc.json
new file mode 100644
index 0000000..7dbda85
--- /dev/null
+++ b/arc017/contest.acc.json
@@ -0,0 +1,53 @@
+{
+  "contest": {
+    "id": "arc017",
+    "title": "AtCoder Regular Contest 017",
+    "url": "https://atcoder.jp/contests/arc017"
+  },
+  "tasks": [
+    {
+      "id": "arc017_1",
+      "label": "A",
+      "title": "素数、コンテスト、素数",
+      "url": "https://atcoder.jp/contests/arc017/tasks/arc017_1",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "arc017_2",
+      "label": "B",
+      "title": "解像度が低い。",
+      "url": "https://atcoder.jp/contests/arc017/tasks/arc017_2",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "arc017_3",
+      "label": "C",
+      "title": "無駄なものが嫌いな人",
+      "url": "https://atcoder.jp/contests/arc017/tasks/arc017_3",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "arc017_4",
+      "label": "D",
+      "title": "ARCたんクッキー",
+      "url": "https://atcoder.jp/contests/arc017/tasks/arc017_4",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/arc017/d/main.py b/arc017/d/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/arc017/d/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 56f17990ef1ca0e2d90dd688e0143257d3845a5f Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Fri, 30 Oct 2020 12:56:53 +0900
Subject: [PATCH 02/13] chore

---
 code-thanks-festival-2017/a/main.py        | 46 ++++++++++
 code-thanks-festival-2017/b/main.py        | 46 ++++++++++
 code-thanks-festival-2017/c/main.py        | 46 ++++++++++
 code-thanks-festival-2017/contest.acc.json | 97 ++++++++++++++++++++++
 code-thanks-festival-2017/d/main.py        | 46 ++++++++++
 code-thanks-festival-2017/e/main.py        | 46 ++++++++++
 code-thanks-festival-2017/f/main.py        | 46 ++++++++++
 code-thanks-festival-2017/g/main.py        | 47 +++++++++++
 code-thanks-festival-2017/h/main.py        | 46 ++++++++++
 9 files changed, 466 insertions(+)
 create mode 100644 code-thanks-festival-2017/a/main.py
 create mode 100644 code-thanks-festival-2017/b/main.py
 create mode 100644 code-thanks-festival-2017/c/main.py
 create mode 100644 code-thanks-festival-2017/contest.acc.json
 create mode 100644 code-thanks-festival-2017/d/main.py
 create mode 100644 code-thanks-festival-2017/e/main.py
 create mode 100644 code-thanks-festival-2017/f/main.py
 create mode 100644 code-thanks-festival-2017/g/main.py
 create mode 100644 code-thanks-festival-2017/h/main.py

diff --git a/code-thanks-festival-2017/a/main.py b/code-thanks-festival-2017/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/code-thanks-festival-2017/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/b/main.py b/code-thanks-festival-2017/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/code-thanks-festival-2017/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/c/main.py b/code-thanks-festival-2017/c/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/code-thanks-festival-2017/c/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/contest.acc.json b/code-thanks-festival-2017/contest.acc.json
new file mode 100644
index 0000000..7d3ba51
--- /dev/null
+++ b/code-thanks-festival-2017/contest.acc.json
@@ -0,0 +1,97 @@
+{
+  "contest": {
+    "id": "code-thanks-festival-2017",
+    "title": "CODE THANKS FESTIVAL 2017",
+    "url": "https://atcoder.jp/contests/code-thanks-festival-2017"
+  },
+  "tasks": [
+    {
+      "id": "code_thanks_festival_2017_a",
+      "label": "A",
+      "title": "Time Penalty",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "code_thanks_festival_2017_b",
+      "label": "B",
+      "title": "Concatenated Palindrome",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "code_thanks_festival_2017_c",
+      "label": "C",
+      "title": "Factory",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_c",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "code_thanks_festival_2017_d",
+      "label": "D",
+      "title": "Bus Tour",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_d",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "code_thanks_festival_2017_e",
+      "label": "E",
+      "title": "Coin Authentication",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_e",
+      "directory": {
+        "path": "e",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "code_thanks_festival_2017_f",
+      "label": "F",
+      "title": "Limited Xor Subset",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_f",
+      "directory": {
+        "path": "f",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "code_thanks_festival_2017_g",
+      "label": "G",
+      "title": "Mixture Drug",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_g",
+      "directory": {
+        "path": "g",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "code_thanks_festival_2017_h",
+      "label": "H",
+      "title": "Union Sets",
+      "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_h",
+      "directory": {
+        "path": "h",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/code-thanks-festival-2017/d/main.py b/code-thanks-festival-2017/d/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/code-thanks-festival-2017/d/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/e/main.py b/code-thanks-festival-2017/e/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/code-thanks-festival-2017/e/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/f/main.py b/code-thanks-festival-2017/f/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/code-thanks-festival-2017/f/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/g/main.py b/code-thanks-festival-2017/g/main.py
new file mode 100644
index 0000000..3e7e541
--- /dev/null
+++ b/code-thanks-festival-2017/g/main.py
@@ -0,0 +1,47 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N, M = LI()
+    AB = LIR(M)
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/h/main.py b/code-thanks-festival-2017/h/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/code-thanks-festival-2017/h/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 709880590f7e07a72987752695fc5a5c0c69a263 Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Sat, 31 Oct 2020 12:04:43 +0900
Subject: [PATCH 03/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc180/d/main.py                    | 13 ++++++++-
 code-thanks-festival-2017/g/main.py | 45 ++++++++++++++++++++++++++++-
 2 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/abc180/d/main.py b/abc180/d/main.py
index e02bf25..950d8ef 100644
--- a/abc180/d/main.py
+++ b/abc180/d/main.py
@@ -37,7 +37,18 @@ def make_list(n, *args, default=0): return [make_list(*args, default=default) fo
 sys.setrecursionlimit(1000000)
 
 def main():
-    N = I()
+    X, Y, A, B = LI()
+    ans = 0
+    C = X * (A - 1)
+    while C <= B:
+        X *= A
+        C = X * (A - 1)
+        ans += 1
+    ans += (Y - X) // B
+    X += B * ((Y - X) // B)
+    if X == Y: ans -= 1
+    print(ans)
+
 
 if __name__ == '__main__':
     main()
\ No newline at end of file
diff --git a/code-thanks-festival-2017/g/main.py b/code-thanks-festival-2017/g/main.py
index 3e7e541..fc2d4e8 100644
--- a/code-thanks-festival-2017/g/main.py
+++ b/code-thanks-festival-2017/g/main.py
@@ -41,7 +41,50 @@ def make_list(n, *args, default=0): return [make_list(*args, default=default) fo
 
 def main():
     N, M = LI()
-    AB = LIR(M)
+    AB = LIR1(M)
+    s = [(1<<N - N//2)-1]*(1 << N//2)
+
+    ok1 = [True]*(1<<N//2)
+    ok2 = [True]*(1<<N-N//2)
+    for a, b in AB:
+        if a < N//2 and b < N//2:
+            ok1[(1 << a) | (1 << b)] = False
+
+        elif a >= N//2 and b >= N//2:
+            ok2[(1 << a-N//2) | (1 << b-N//2)] = False
+
+        else:
+            a, b = min(a, b), max(a, b)
+            s[1 << a] ^= 1 << b - N//2
+
+
+    for i in range(1 << N//2):
+        if not ok1[i]:
+            for w in range(N//2):
+                ok1[i | (1 << w)] = False
+    for i in range(1 << N-N//2):
+        if not ok2[i]:
+            for w in range(N-N//2):
+                ok2[i | (1 << w)] = False
+
+
+    for i in range(1<<N//2):
+        for w in range(N//2):
+            s[i | (1 << w)] = s[i] & s[1 << w]
+
+
+    dp = [None]*(1 << N - N//2)
+    for i in range(1 << N - N//2):
+        dp[i] = bin(i).count("1") if ok2[i] else 0
+    for i in range(1 << N - N//2):
+        for w in range(N - N//2):
+            dp[i | (1 << w)] = max(dp[i | (1 << w)], dp[i])
+
+    ans = 0
+    for i in range(1 << N//2):
+        if ok1[i]:
+            ans = max(bin(i).count("1") + dp[s[i]], ans)
+    print(ans)
 
 if __name__ == '__main__':
     main()
\ No newline at end of file

From b1209d124afb38dcd4b87c1c3ab96f30a05de3ae Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Tue, 3 Nov 2020 12:16:34 +0900
Subject: [PATCH 04/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc124/a/main.py        | 46 ++++++++++++++++++++++++++
 abc124/b/main.py        | 46 ++++++++++++++++++++++++++
 abc124/c/main.py        | 46 ++++++++++++++++++++++++++
 abc124/contest.acc.json | 53 ++++++++++++++++++++++++++++++
 abc124/d/main.py        | 73 +++++++++++++++++++++++++++++++++++++++++
 abc180/d/main.py        |  2 +-
 6 files changed, 265 insertions(+), 1 deletion(-)
 create mode 100644 abc124/a/main.py
 create mode 100644 abc124/b/main.py
 create mode 100644 abc124/c/main.py
 create mode 100644 abc124/contest.acc.json
 create mode 100644 abc124/d/main.py

diff --git a/abc124/a/main.py b/abc124/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc124/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc124/b/main.py b/abc124/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc124/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc124/c/main.py b/abc124/c/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc124/c/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc124/contest.acc.json b/abc124/contest.acc.json
new file mode 100644
index 0000000..19be7ce
--- /dev/null
+++ b/abc124/contest.acc.json
@@ -0,0 +1,53 @@
+{
+  "contest": {
+    "id": "abc124",
+    "title": "AtCoder Beginner Contest 124",
+    "url": "https://atcoder.jp/contests/abc124"
+  },
+  "tasks": [
+    {
+      "id": "abc124_a",
+      "label": "A",
+      "title": "Buttons",
+      "url": "https://atcoder.jp/contests/abc124/tasks/abc124_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc124_b",
+      "label": "B",
+      "title": "Great Ocean View",
+      "url": "https://atcoder.jp/contests/abc124/tasks/abc124_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc124_c",
+      "label": "C",
+      "title": "Coloring Colorfully",
+      "url": "https://atcoder.jp/contests/abc124/tasks/abc124_c",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc124_d",
+      "label": "D",
+      "title": "Handstand",
+      "url": "https://atcoder.jp/contests/abc124/tasks/abc124_d",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/abc124/d/main.py b/abc124/d/main.py
new file mode 100644
index 0000000..f09517f
--- /dev/null
+++ b/abc124/d/main.py
@@ -0,0 +1,73 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N, K = LI()
+    S = SL()
+
+    tmp = []
+    cnt = 1
+    for i in range(1, N):
+        if S[i-1] == S[i]:
+            cnt += 1
+        else:
+            tmp.append((cnt, abs(int(S[i-1]) - 1)))
+            cnt = 1
+    tmp.append((cnt, abs(int(S[-1]) - 1)))
+
+    ans = 0
+    left = 0
+    now = 0
+    k = 0
+    for right in range(len(tmp)):
+        now += tmp[right][0]
+        k += tmp[right][1]
+        while k > K:
+            now -= tmp[left][0]
+            k -= tmp[left][1]
+            left += 1
+        ans = max(ans, now)
+    print(ans)
+
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc180/d/main.py b/abc180/d/main.py
index 950d8ef..f41e088 100644
--- a/abc180/d/main.py
+++ b/abc180/d/main.py
@@ -40,7 +40,7 @@ def main():
     X, Y, A, B = LI()
     ans = 0
     C = X * (A - 1)
-    while C <= B:
+    while C <= B and X * A < Y:
         X *= A
         C = X * (A - 1)
         ans += 1

From 753c6459babd081d1d46fad7cce34f684a0d48be Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Wed, 4 Nov 2020 10:28:36 +0900
Subject: [PATCH 05/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc118/a/main.py        | 46 +++++++++++++++++++++++++++++++++++
 abc118/b/main.py        | 46 +++++++++++++++++++++++++++++++++++
 abc118/c/main.py        | 48 +++++++++++++++++++++++++++++++++++++
 abc118/contest.acc.json | 53 +++++++++++++++++++++++++++++++++++++++++
 abc118/d/main.py        | 46 +++++++++++++++++++++++++++++++++++
 5 files changed, 239 insertions(+)
 create mode 100644 abc118/a/main.py
 create mode 100644 abc118/b/main.py
 create mode 100644 abc118/c/main.py
 create mode 100644 abc118/contest.acc.json
 create mode 100644 abc118/d/main.py

diff --git a/abc118/a/main.py b/abc118/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc118/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc118/b/main.py b/abc118/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc118/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc118/c/main.py b/abc118/c/main.py
new file mode 100644
index 0000000..9ad78d6
--- /dev/null
+++ b/abc118/c/main.py
@@ -0,0 +1,48 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+    A = LI()
+    print(reduce(lambda x, y: math.gcd(x, y), A))
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc118/contest.acc.json b/abc118/contest.acc.json
new file mode 100644
index 0000000..6e965ed
--- /dev/null
+++ b/abc118/contest.acc.json
@@ -0,0 +1,53 @@
+{
+  "contest": {
+    "id": "abc118",
+    "title": "AtCoder Beginner Contest 118",
+    "url": "https://atcoder.jp/contests/abc118"
+  },
+  "tasks": [
+    {
+      "id": "abc118_a",
+      "label": "A",
+      "title": "B +/- A",
+      "url": "https://atcoder.jp/contests/abc118/tasks/abc118_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc118_b",
+      "label": "B",
+      "title": "Foods Loved by Everyone",
+      "url": "https://atcoder.jp/contests/abc118/tasks/abc118_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc118_c",
+      "label": "C",
+      "title": "Monsters Battle Royale",
+      "url": "https://atcoder.jp/contests/abc118/tasks/abc118_c",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc118_d",
+      "label": "D",
+      "title": "Match Matching",
+      "url": "https://atcoder.jp/contests/abc118/tasks/abc118_d",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/abc118/d/main.py b/abc118/d/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc118/d/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 9e46daa3f0c84b5fa6a6b37011614b1fe2c1ca29 Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Sat, 7 Nov 2020 21:28:51 +0900
Subject: [PATCH 06/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc121/a/main.py        | 46 +++++++++++++++++++++++++++++++++++
 abc121/b/main.py        | 46 +++++++++++++++++++++++++++++++++++
 abc121/c/main.py        | 46 +++++++++++++++++++++++++++++++++++
 abc121/contest.acc.json | 53 +++++++++++++++++++++++++++++++++++++++++
 abc121/d/main.py        | 47 ++++++++++++++++++++++++++++++++++++
 abc129/c/main.py        | 17 +++++++++++--
 6 files changed, 253 insertions(+), 2 deletions(-)
 create mode 100644 abc121/a/main.py
 create mode 100644 abc121/b/main.py
 create mode 100644 abc121/c/main.py
 create mode 100644 abc121/contest.acc.json
 create mode 100644 abc121/d/main.py

diff --git a/abc121/a/main.py b/abc121/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc121/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc121/b/main.py b/abc121/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc121/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc121/c/main.py b/abc121/c/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc121/c/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc121/contest.acc.json b/abc121/contest.acc.json
new file mode 100644
index 0000000..ff75372
--- /dev/null
+++ b/abc121/contest.acc.json
@@ -0,0 +1,53 @@
+{
+  "contest": {
+    "id": "abc121",
+    "title": "AtCoder Beginner Contest 121",
+    "url": "https://atcoder.jp/contests/abc121"
+  },
+  "tasks": [
+    {
+      "id": "abc121_a",
+      "label": "A",
+      "title": "White Cells",
+      "url": "https://atcoder.jp/contests/abc121/tasks/abc121_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc121_b",
+      "label": "B",
+      "title": "Can you solve this?",
+      "url": "https://atcoder.jp/contests/abc121/tasks/abc121_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc121_c",
+      "label": "C",
+      "title": "Energy Drink Collector",
+      "url": "https://atcoder.jp/contests/abc121/tasks/abc121_c",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc121_d",
+      "label": "D",
+      "title": "XOR World",
+      "url": "https://atcoder.jp/contests/abc121/tasks/abc121_d",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/abc121/d/main.py b/abc121/d/main.py
new file mode 100644
index 0000000..d9b1b77
--- /dev/null
+++ b/abc121/d/main.py
@@ -0,0 +1,47 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    A, B = LI()
+
+    
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc129/c/main.py b/abc129/c/main.py
index 4783c85..a63c74f 100644
--- a/abc129/c/main.py
+++ b/abc129/c/main.py
@@ -17,10 +17,23 @@ def LSR(n): return [LS() for i in range(n)]
 sys.setrecursionlimit(1000000)
 dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
 dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
-MOD = 1000000007
+MOD = 1_000_000_007
 
 def main():
-    N = I()
+    N, M = LI()
+    A = set(IR(M))
+
+    dp = [0]*(N+1)
+    dp[0] = 1
+    dp[1] = 1 if 1 not in A else 0
+
+    for i in range(2, N+1):
+        dp[i] = (dp[i-1] + dp[i-2]) % MOD
+        if i in A:
+            dp[i] = 0
+    print(dp[-1])
+
+
 
 if __name__ == '__main__':
     main()
\ No newline at end of file

From d54f8ee95cf9952d3c4945fd11c965710b2fac1a Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Sun, 8 Nov 2020 17:29:19 +0900
Subject: [PATCH 07/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc124/c/main.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/abc124/c/main.py b/abc124/c/main.py
index f0bbc5c..f68a2a4 100644
--- a/abc124/c/main.py
+++ b/abc124/c/main.py
@@ -40,7 +40,10 @@ def make_list(n, *args, default=0): return [make_list(*args, default=default) fo
 sys.setrecursionlimit(1000000)
 
 def main():
-    N = I()
+    S = SL()
+    L1 = [str(i % 2) for i in range(len(S))]
+    L2 = [str((i+1) % 2) for i in range(len(S))]
+    print(min(sum(1 for ch, l1 in zip(S, L1) if ch != l1), sum(1 for ch, l2 in zip(S, L2) if ch != l2)))
 
 if __name__ == '__main__':
     main()
\ No newline at end of file

From 70d540f357529357200d1807f73f0cd23c8a0144 Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Wed, 11 Nov 2020 19:36:46 +0900
Subject: [PATCH 08/13] chore

---
 abc121/c/main.py | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/abc121/c/main.py b/abc121/c/main.py
index f0bbc5c..b8ea419 100644
--- a/abc121/c/main.py
+++ b/abc121/c/main.py
@@ -40,7 +40,19 @@ def make_list(n, *args, default=0): return [make_list(*args, default=default) fo
 sys.setrecursionlimit(1000000)
 
 def main():
-    N = I()
+    N, M = LI()
+    AB = sorted(LIR(N))
+    count = 0
+    now = 0
+    ans = 0
+    while count < M:
+        if AB[now][1] == 0:
+            now += 1
+        ans += AB[now][0]
+        count += 1
+        AB[now][1] -= 1
+    print(ans)
+
 
 if __name__ == '__main__':
     main()
\ No newline at end of file

From 73227e6e83cdda6e9819d19cc2350c8c3308f3f6 Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Sun, 15 Nov 2020 12:35:59 +0900
Subject: [PATCH 09/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc181/a/main.py        | 46 +++++++++++++++++++++++++
 abc181/b/main.py        | 46 +++++++++++++++++++++++++
 abc181/c/main.py        | 46 +++++++++++++++++++++++++
 abc181/contest.acc.json | 75 +++++++++++++++++++++++++++++++++++++++++
 abc181/d/main.py        | 59 ++++++++++++++++++++++++++++++++
 abc181/e/main.py        | 46 +++++++++++++++++++++++++
 abc181/f/main.py        | 46 +++++++++++++++++++++++++
 7 files changed, 364 insertions(+)
 create mode 100644 abc181/a/main.py
 create mode 100644 abc181/b/main.py
 create mode 100644 abc181/c/main.py
 create mode 100644 abc181/contest.acc.json
 create mode 100644 abc181/d/main.py
 create mode 100644 abc181/e/main.py
 create mode 100644 abc181/f/main.py

diff --git a/abc181/a/main.py b/abc181/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc181/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc181/b/main.py b/abc181/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc181/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc181/c/main.py b/abc181/c/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc181/c/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc181/contest.acc.json b/abc181/contest.acc.json
new file mode 100644
index 0000000..b07dd2d
--- /dev/null
+++ b/abc181/contest.acc.json
@@ -0,0 +1,75 @@
+{
+  "contest": {
+    "id": "abc181",
+    "title": "AtCoder Beginner Contest 181",
+    "url": "https://atcoder.jp/contests/abc181"
+  },
+  "tasks": [
+    {
+      "id": "abc181_a",
+      "label": "A",
+      "title": "Heavy Rotation",
+      "url": "https://atcoder.jp/contests/abc181/tasks/abc181_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc181_b",
+      "label": "B",
+      "title": "Trapezoid Sum",
+      "url": "https://atcoder.jp/contests/abc181/tasks/abc181_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc181_c",
+      "label": "C",
+      "title": "Collinearity",
+      "url": "https://atcoder.jp/contests/abc181/tasks/abc181_c",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc181_d",
+      "label": "D",
+      "title": "Hachi",
+      "url": "https://atcoder.jp/contests/abc181/tasks/abc181_d",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc181_e",
+      "label": "E",
+      "title": "Transformable Teacher",
+      "url": "https://atcoder.jp/contests/abc181/tasks/abc181_e",
+      "directory": {
+        "path": "e",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc181_f",
+      "label": "F",
+      "title": "Silver Woods",
+      "url": "https://atcoder.jp/contests/abc181/tasks/abc181_f",
+      "directory": {
+        "path": "f",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/abc181/d/main.py b/abc181/d/main.py
new file mode 100644
index 0000000..db04b1b
--- /dev/null
+++ b/abc181/d/main.py
@@ -0,0 +1,59 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    S = SL()
+    C = Counter(S)
+
+    if len(S) <= 2:
+        print("Yes" if (int("".join(S)) % 8 == 0 or int("".join(S[::-1])) % 8 == 0) else "No")
+        exit(0)
+
+    for i in range(104, 1000, 8):
+        c = Counter(str(i))
+        if all((C.get(t) or 0) >= c.get(t) for t in c):
+            print("Yes")
+            break
+    else:
+        print("No")
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc181/e/main.py b/abc181/e/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc181/e/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc181/f/main.py b/abc181/f/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc181/f/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From cd007303eee96650e4278d8d90561b65c3995af0 Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Mon, 16 Nov 2020 11:13:52 +0900
Subject: [PATCH 10/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc181/e/main.py | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/abc181/e/main.py b/abc181/e/main.py
index f0bbc5c..185f76c 100644
--- a/abc181/e/main.py
+++ b/abc181/e/main.py
@@ -40,7 +40,24 @@ def make_list(n, *args, default=0): return [make_list(*args, default=default) fo
 sys.setrecursionlimit(1000000)
 
 def main():
-    N = I()
+    N, M = LI()
+    H = sorted(LI())
+    W = LI()
+
+    r1 = [H[i+1]-H[i] for i in range(0, N-1, 2)]
+    c1 = [0] + list(accumulate(r1))
+    r2 = [H[i+1]-H[i] for i in range(1, N-1, 2)]
+    c2 = [0] + list(accumulate(r2))
+
+    ans = INF
+
+    for w in W:
+        i = bisect_left(H, w)
+        ans = min(ans, abs(H[(i//2)*2] - w) + c1[i//2] + c2[-1] - c2[i//2])
+    print(ans)
+
+
+
 
 if __name__ == '__main__':
     main()
\ No newline at end of file

From 5fd60427c1c08e0f18ed5f65c99e396a8bf4e917 Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Wed, 18 Nov 2020 15:09:47 +0900
Subject: [PATCH 11/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc111/a/main.py        | 46 +++++++++++++++++++++++++++++
 abc111/b/main.py        | 46 +++++++++++++++++++++++++++++
 abc111/c/main.py        | 64 +++++++++++++++++++++++++++++++++++++++++
 abc111/contest.acc.json | 53 ++++++++++++++++++++++++++++++++++
 abc111/d/main.py        | 46 +++++++++++++++++++++++++++++
 5 files changed, 255 insertions(+)
 create mode 100644 abc111/a/main.py
 create mode 100644 abc111/b/main.py
 create mode 100644 abc111/c/main.py
 create mode 100644 abc111/contest.acc.json
 create mode 100644 abc111/d/main.py

diff --git a/abc111/a/main.py b/abc111/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc111/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc111/b/main.py b/abc111/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc111/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc111/c/main.py b/abc111/c/main.py
new file mode 100644
index 0000000..9282ffb
--- /dev/null
+++ b/abc111/c/main.py
@@ -0,0 +1,64 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    n = I()
+    V = LI()
+    c1 = Counter(V[::2])
+    c2 = Counter(V[1::2])
+
+    (r1, d1), (r2, d2) = c1.most_common(1)[0], c2.most_common(1)[0]
+    if r1 == r2:
+        w1, w2 = c1.most_common(2), c2.most_common(2)
+        (r3, d3), (r4, d4) = w1[-1], w2[-1]
+        if len(w1) >= 2 and len(w2) >= 2:
+            print(min(n - d3 - d2, n - d1 - d4))
+        elif len(w1) == 1 and len(w2) >= 2:
+            print(n - d1 - d4)
+        elif len(w1) >= 2 and len(w2) == 1:
+            print(n - d2 - d3)
+        else:
+            print(n - d1)
+    else:
+        print(n - d1 - d2)
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc111/contest.acc.json b/abc111/contest.acc.json
new file mode 100644
index 0000000..713b708
--- /dev/null
+++ b/abc111/contest.acc.json
@@ -0,0 +1,53 @@
+{
+  "contest": {
+    "id": "abc111",
+    "title": "AtCoder Beginner Contest 111",
+    "url": "https://atcoder.jp/contests/abc111"
+  },
+  "tasks": [
+    {
+      "id": "abc111_a",
+      "label": "A",
+      "title": "AtCoder Beginner Contest 999",
+      "url": "https://atcoder.jp/contests/abc111/tasks/abc111_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc111_b",
+      "label": "B",
+      "title": "AtCoder Beginner Contest 111",
+      "url": "https://atcoder.jp/contests/abc111/tasks/abc111_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "arc103_a",
+      "label": "C",
+      "title": "/\\/\\/\\/",
+      "url": "https://atcoder.jp/contests/abc111/tasks/arc103_a",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "arc103_b",
+      "label": "D",
+      "title": "Robot Arms",
+      "url": "https://atcoder.jp/contests/abc111/tasks/arc103_b",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/abc111/d/main.py b/abc111/d/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc111/d/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 293aa6c5ed6292912a45402be7fe1c620041febf Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Sat, 13 Mar 2021 17:24:42 +0900
Subject: [PATCH 12/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc194/a/main.py        | 46 +++++++++++++++++++++++++
 abc194/b/main.py        | 46 +++++++++++++++++++++++++
 abc194/c/main.py        | 71 ++++++++++++++++++++++++++++++++++++++
 abc194/contest.acc.json | 75 +++++++++++++++++++++++++++++++++++++++++
 abc194/d/main.py        | 46 +++++++++++++++++++++++++
 abc194/e/main.py        | 46 +++++++++++++++++++++++++
 abc194/f/main.py        | 46 +++++++++++++++++++++++++
 7 files changed, 376 insertions(+)
 create mode 100644 abc194/a/main.py
 create mode 100644 abc194/b/main.py
 create mode 100644 abc194/c/main.py
 create mode 100644 abc194/contest.acc.json
 create mode 100644 abc194/d/main.py
 create mode 100644 abc194/e/main.py
 create mode 100644 abc194/f/main.py

diff --git a/abc194/a/main.py b/abc194/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc194/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc194/b/main.py b/abc194/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc194/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc194/c/main.py b/abc194/c/main.py
new file mode 100644
index 0000000..3d201eb
--- /dev/null
+++ b/abc194/c/main.py
@@ -0,0 +1,71 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math
+import fractions
+import sys
+import copy
+
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+
+
+def comb(n, r): return math.factorial(
+    n) // (math.factorial(r) * math.factorial(n-r))
+
+
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default)
+                                            for _ in range(n)] if args else [default for _ in range(n)]
+
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+
+def main():
+    N = I()
+    A = LI()
+
+    cnt = [0] * 401
+    for a in A:
+        cnt[a+200] += 1
+
+    ans = 0
+    for i, c1 in enumerate(cnt):
+        for j, c2 in enumerate(cnt):
+            ans += c1*c2*(((i-200) - (j-200))**2)
+    print(ans//2)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/abc194/contest.acc.json b/abc194/contest.acc.json
new file mode 100644
index 0000000..55b5769
--- /dev/null
+++ b/abc194/contest.acc.json
@@ -0,0 +1,75 @@
+{
+  "contest": {
+    "id": "abc194",
+    "title": "AtCoder Beginner Contest 194",
+    "url": "https://atcoder.jp/contests/abc194"
+  },
+  "tasks": [
+    {
+      "id": "abc194_a",
+      "label": "A",
+      "title": "I Scream",
+      "url": "https://atcoder.jp/contests/abc194/tasks/abc194_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc194_b",
+      "label": "B",
+      "title": "Job Assignment",
+      "url": "https://atcoder.jp/contests/abc194/tasks/abc194_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc194_c",
+      "label": "C",
+      "title": "Squared Error",
+      "url": "https://atcoder.jp/contests/abc194/tasks/abc194_c",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc194_d",
+      "label": "D",
+      "title": "Journey",
+      "url": "https://atcoder.jp/contests/abc194/tasks/abc194_d",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc194_e",
+      "label": "E",
+      "title": "Mex Min",
+      "url": "https://atcoder.jp/contests/abc194/tasks/abc194_e",
+      "directory": {
+        "path": "e",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc194_f",
+      "label": "F",
+      "title": "Digits Paradise in Hexadecimal",
+      "url": "https://atcoder.jp/contests/abc194/tasks/abc194_f",
+      "directory": {
+        "path": "f",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/abc194/d/main.py b/abc194/d/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc194/d/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc194/e/main.py b/abc194/e/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc194/e/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc194/f/main.py b/abc194/f/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc194/f/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From bbaa387375bc488df48c3b51bad65e026fe8b0cc Mon Sep 17 00:00:00 2001
From: hppRC <hpp.ricecake@gmail.com>
Date: Sun, 14 Mar 2021 17:08:14 +0900
Subject: [PATCH 13/13] =?UTF-8?q?=F0=9F=A5=BAchore?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 abc193/a/main.py        | 46 +++++++++++++++++++++++++
 abc193/b/main.py        | 46 +++++++++++++++++++++++++
 abc193/c/main.py        | 66 ++++++++++++++++++++++++++++++++++++
 abc193/contest.acc.json | 75 +++++++++++++++++++++++++++++++++++++++++
 abc193/d/main.py        | 46 +++++++++++++++++++++++++
 abc193/e/main.py        | 46 +++++++++++++++++++++++++
 abc193/f/main.py        | 46 +++++++++++++++++++++++++
 7 files changed, 371 insertions(+)
 create mode 100644 abc193/a/main.py
 create mode 100644 abc193/b/main.py
 create mode 100644 abc193/c/main.py
 create mode 100644 abc193/contest.acc.json
 create mode 100644 abc193/d/main.py
 create mode 100644 abc193/e/main.py
 create mode 100644 abc193/f/main.py

diff --git a/abc193/a/main.py b/abc193/a/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc193/a/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc193/b/main.py b/abc193/b/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc193/b/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc193/c/main.py b/abc193/c/main.py
new file mode 100644
index 0000000..cffd605
--- /dev/null
+++ b/abc193/c/main.py
@@ -0,0 +1,66 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math
+import fractions
+import sys
+import copy
+
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+
+
+def comb(n, r): return math.factorial(
+    n) // (math.factorial(r) * math.factorial(n-r))
+
+
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default)
+                                            for _ in range(n)] if args else [default for _ in range(n)]
+
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+
+def main():
+    N = I()
+    s = set()
+    for a in range(2, math.ceil(math.sqrt(N))+1):
+        for b in range(2, math.ceil(math.log(N, a))+1):
+            if a**b <= N:
+                s.add(a**b)
+    print(N-len(s))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/abc193/contest.acc.json b/abc193/contest.acc.json
new file mode 100644
index 0000000..1b3f1ae
--- /dev/null
+++ b/abc193/contest.acc.json
@@ -0,0 +1,75 @@
+{
+  "contest": {
+    "id": "abc193",
+    "title": "Caddi Programming Contest 2021(AtCoder Beginner Contest 193)",
+    "url": "https://atcoder.jp/contests/abc193"
+  },
+  "tasks": [
+    {
+      "id": "abc193_a",
+      "label": "A",
+      "title": "Discount",
+      "url": "https://atcoder.jp/contests/abc193/tasks/abc193_a",
+      "directory": {
+        "path": "a",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc193_b",
+      "label": "B",
+      "title": "Play Snuke",
+      "url": "https://atcoder.jp/contests/abc193/tasks/abc193_b",
+      "directory": {
+        "path": "b",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc193_c",
+      "label": "C",
+      "title": "Unexpressed",
+      "url": "https://atcoder.jp/contests/abc193/tasks/abc193_c",
+      "directory": {
+        "path": "c",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc193_d",
+      "label": "D",
+      "title": "Poker",
+      "url": "https://atcoder.jp/contests/abc193/tasks/abc193_d",
+      "directory": {
+        "path": "d",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc193_e",
+      "label": "E",
+      "title": "Oversleeping",
+      "url": "https://atcoder.jp/contests/abc193/tasks/abc193_e",
+      "directory": {
+        "path": "e",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    },
+    {
+      "id": "abc193_f",
+      "label": "F",
+      "title": "Zebraness",
+      "url": "https://atcoder.jp/contests/abc193/tasks/abc193_f",
+      "directory": {
+        "path": "f",
+        "testdir": "test",
+        "submit": "main.py"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/abc193/d/main.py b/abc193/d/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc193/d/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc193/e/main.py b/abc193/e/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc193/e/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/abc193/f/main.py b/abc193/f/main.py
new file mode 100644
index 0000000..f0bbc5c
--- /dev/null
+++ b/abc193/f/main.py
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+from collections import defaultdict, deque, Counter, OrderedDict
+from bisect import bisect_left, bisect_right
+from functools import reduce, lru_cache
+from heapq import heappush, heappop, heapify
+
+from itertools import *
+import math, fractions
+import sys, copy
+
+def L(): return sys.stdin.readline().split()
+def I(): return int(sys.stdin.readline().rstrip())
+def SL(): return list(sys.stdin.readline().rstrip())
+def LI(): return [int(x) for x in sys.stdin.readline().split()]
+def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
+def LS(): return [list(x) for x in sys.stdin.readline().split()]
+def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
+def LR(n): return [L() for _ in range(n)]
+def IR(n): return [I() for _ in range(n)]
+def LIR(n): return [LI() for _ in range(n)]
+def LIR1(n): return [LI1() for _ in range(n)]
+def SLR(n): return [SL() for _ in range(n)]
+def LSR(n): return [LS() for _ in range(n)]
+
+def perm(n, r): return math.factorial(n) // math.factorial(r)
+def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
+def powerset(iterable):
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
+
+dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+alphabets = "abcdefghijklmnopqrstuvwxyz"
+ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+MOD = 1000000007
+INF = float("inf")
+
+sys.setrecursionlimit(1000000)
+
+def main():
+    N = I()
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file