diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index 042d124..a956e73 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.7, 3.8]
+        python-version: [3.6, 3.7, 3.8]
 
     steps:
     - uses: actions/checkout@v2
diff --git a/atcoder/maxflow.py b/atcoder/maxflow.py
index 72905df..eb75dde 100644
--- a/atcoder/maxflow.py
+++ b/atcoder/maxflow.py
@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from typing import NamedTuple, Optional, List, cast
 
 
diff --git a/atcoder/mincostflow.py b/atcoder/mincostflow.py
index 3e41739..4908b89 100644
--- a/atcoder/mincostflow.py
+++ b/atcoder/mincostflow.py
@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from typing import NamedTuple, Optional, List, Tuple, cast
 from heapq import heappush, heappop
 
diff --git a/atcoder/modint.py b/atcoder/modint.py
index e44d624..d599327 100644
--- a/atcoder/modint.py
+++ b/atcoder/modint.py
@@ -1,4 +1,3 @@
-from __future__ import annotations
 import typing
 
 import atcoder._math
@@ -38,7 +37,7 @@ def mod(self) -> int:
     def val(self) -> int:
         return self._v
 
-    def __iadd__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __iadd__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             self._v += rhs._v
         else:
@@ -47,7 +46,7 @@ def __iadd__(self, rhs: typing.Union[Modint, int]) -> Modint:
             self._v -= self._mod
         return self
 
-    def __isub__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __isub__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             self._v -= rhs._v
         else:
@@ -56,14 +55,14 @@ def __isub__(self, rhs: typing.Union[Modint, int]) -> Modint:
             self._v += self._mod
         return self
 
-    def __imul__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __imul__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             self._v = self._v * rhs._v % self._mod
         else:
             self._v = self._v * rhs % self._mod
         return self
 
-    def __ifloordiv__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __ifloordiv__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             inv = rhs.inv()._v
         else:
@@ -71,25 +70,25 @@ def __ifloordiv__(self, rhs: typing.Union[Modint, int]) -> Modint:
         self._v = self._v * inv % self._mod
         return self
 
-    def __pos__(self) -> Modint:
+    def __pos__(self) -> 'Modint':
         return self
 
-    def __neg__(self) -> Modint:
+    def __neg__(self) -> 'Modint':
         return Modint() - self
 
-    def __pow__(self, n: int) -> Modint:
+    def __pow__(self, n: int) -> 'Modint':
         assert 0 <= n
 
         return Modint(pow(self._v, n, self._mod))
 
-    def inv(self) -> Modint:
+    def inv(self) -> 'Modint':
         eg = atcoder._math._inv_gcd(self._v, self._mod)
 
         assert eg[0] == 1
 
         return Modint(eg[1])
 
-    def __add__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __add__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             result = self._v + rhs._v
             if result >= self._mod:
@@ -98,7 +97,7 @@ def __add__(self, rhs: typing.Union[Modint, int]) -> Modint:
         else:
             return Modint(self._v + rhs)
 
-    def __sub__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __sub__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             result = self._v - rhs._v
             if result < 0:
@@ -107,26 +106,26 @@ def __sub__(self, rhs: typing.Union[Modint, int]) -> Modint:
         else:
             return Modint(self._v - rhs)
 
-    def __mul__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __mul__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             return Modint(self._v * rhs._v)
         else:
             return Modint(self._v * rhs)
 
-    def __floordiv__(self, rhs: typing.Union[Modint, int]) -> Modint:
+    def __floordiv__(self, rhs: typing.Union['Modint', int]) -> 'Modint':
         if isinstance(rhs, Modint):
             inv = rhs.inv()._v
         else:
             inv = atcoder._math._inv_gcd(rhs, self._mod)[1]
         return Modint(self._v * inv)
 
-    def __eq__(self, rhs: typing.Union[Modint, int]) -> bool:  # type: ignore
+    def __eq__(self, rhs: typing.Union['Modint', int]) -> bool:  # type: ignore
         if isinstance(rhs, Modint):
             return self._v == rhs._v
         else:
             return self._v == rhs
 
-    def __ne__(self, rhs: typing.Union[Modint, int]) -> bool:  # type: ignore
+    def __ne__(self, rhs: typing.Union['Modint', int]) -> bool:  # type: ignore
         if isinstance(rhs, Modint):
             return self._v != rhs._v
         else: