diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e3c1c21..9f620cf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,11 +2,13 @@ name: CI
 
 on:
   schedule:
-    - cron: '0 0 * * 6'
+    - cron: "0 0 * * 6"
   push:
     branches:
-      - '*'
+      - "*"
   pull_request:
+    branches:
+      - "master"
 
 jobs:
   rustfmt:
@@ -18,19 +20,19 @@ jobs:
           - stable-x86_64-unknown-linux-gnu
 
     name: Rustfmt (${{ matrix.toolchain }})
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - name: 'Setup `${{ matrix.toolchain }}`'
+      - name: "Setup `${{ matrix.toolchain }}`"
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.toolchain }}
           components: rustfmt
 
-      - name: 'Override `${{ matrix.toolchain }}'
+      - name: "Override `${{ matrix.toolchain }}"
         run: |
           rustup override set ${{ matrix.toolchain }}
 
@@ -44,18 +46,18 @@ jobs:
       matrix:
         toolchain:
           - 1.70.0-x86_64-pc-windows-msvc
-          - 1.70.0-x86_64-apple-darwin
+          - 1.70.0-aarch64-apple-darwin
           - 1.70.0-x86_64-unknown-linux-gnu
           - stable-x86_64-pc-windows-msvc
-          - stable-x86_64-apple-darwin
+          - stable-aarch64-apple-darwin
           - stable-x86_64-unknown-linux-gnu
         include:
-          - { toolchain: 1.70.0-x86_64-pc-windows-msvc  , os: windows-2019 }
-          - { toolchain: 1.70.0-x86_64-apple-darwin     , os: macos-11     }
-          - { toolchain: 1.70.0-x86_64-unknown-linux-gnu, os: ubuntu-20.04 }
-          - { toolchain: stable-x86_64-pc-windows-msvc  , os: windows-2019 }
-          - { toolchain: stable-x86_64-apple-darwin     , os: macos-11     }
-          - { toolchain: stable-x86_64-unknown-linux-gnu, os: ubuntu-20.04 }
+          - { toolchain: 1.70.0-x86_64-pc-windows-msvc, os: windows-2022 }
+          - { toolchain: 1.70.0-aarch64-apple-darwin, os: macos-14 }
+          - { toolchain: 1.70.0-x86_64-unknown-linux-gnu, os: ubuntu-24.04 }
+          - { toolchain: stable-x86_64-pc-windows-msvc, os: windows-2022 }
+          - { toolchain: stable-aarch64-apple-darwin, os: macos-14 }
+          - { toolchain: stable-x86_64-unknown-linux-gnu, os: ubuntu-24.04 }
 
     name: Build (${{ matrix.toolchain }})
     runs-on: ${{ matrix.os }}
@@ -63,18 +65,18 @@ jobs:
     steps:
       - name: Disable `core.autocrlf`
         run: git config --global core.autocrlf false
-        if: matrix.os == 'windows-2019'
+        if: matrix.os == 'windows-2022'
 
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - name: 'Setup `${{ matrix.toolchain }}`'
+      - name: "Setup `${{ matrix.toolchain }}`"
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.toolchain }}
           components: clippy
 
-      - name: 'Override `${{ matrix.toolchain }}`'
+      - name: "Override `${{ matrix.toolchain }}`"
         run: |
           rustup override set ${{ matrix.toolchain }}
 
@@ -100,28 +102,28 @@ jobs:
           - 1.70.0-x86_64-unknown-linux-gnu
           - stable-x86_64-unknown-linux-gnu
         python-version:
-          - '3.6' # https://packages.ubuntu.com/bionic/python3
-          - '3.8' # https://packages.ubuntu.com/focal/python3
+          - "3.12"
+          - "3.13"
 
     name: Expand_test (${{ matrix.toolchain }}, ${{ matrix.python-version }})
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - name: 'Setup `${{ matrix.toolchain }}`'
+      - name: "Setup `${{ matrix.toolchain }}`"
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.toolchain }}
           components: rustfmt
 
-      - name: 'Override `${{ matrix.toolchain }}`'
+      - name: "Override `${{ matrix.toolchain }}`"
         run: |
           rustup override set ${{ matrix.toolchain }}
 
       - name: Setup Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -130,25 +132,25 @@ jobs:
 
   verify:
     name: Verify
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup `1.70.0-x86_64-unknown-linux-gnu`
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: 1.70.0-x86_64-unknown-linux-gnu
 
-      - name: 'Override `1.70.0-x86_64-unknown-linux-gnu'
+      - name: "Override `1.70.0-x86_64-unknown-linux-gnu"
         run: |
           rustup override set 1.70.0-x86_64-unknown-linux-gnu
 
       - name: Setup Python 3.9
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.9'
+          python-version: "3.9"
 
       - name: Install `oj`
         run: pip install online-judge-tools
diff --git a/src/convolution.rs b/src/convolution.rs
index 4d18e13..39f5440 100644
--- a/src/convolution.rs
+++ b/src/convolution.rs
@@ -391,13 +391,13 @@ mod tests {
         }
 
         for i in 0..1000 {
-            let a = vec![i64::min_value() + i];
+            let a = vec![i64::MIN + i];
             let b = vec![1];
             assert_eq!(a, super::convolution_i64(&a, &b));
         }
 
         for i in 0..1000 {
-            let a = vec![i64::max_value() - i];
+            let a = vec![i64::MAX - i];
             let b = vec![1];
             assert_eq!(a, super::convolution_i64(&a, &b));
         }
diff --git a/src/internal_bit.rs b/src/internal_bit.rs
index 5ab7583..898373e 100644
--- a/src/internal_bit.rs
+++ b/src/internal_bit.rs
@@ -25,6 +25,6 @@ mod tests {
         assert_eq!(30, super::ceil_pow2(1 << 30));
         assert_eq!(31, super::ceil_pow2((1 << 30) + 1));
 
-        assert_eq!(32, super::ceil_pow2(u32::max_value()));
+        assert_eq!(32, super::ceil_pow2(u32::MAX));
     }
 }
diff --git a/src/internal_math.rs b/src/internal_math.rs
index c6290b0..9f53a84 100644
--- a/src/internal_math.rs
+++ b/src/internal_math.rs
@@ -27,9 +27,9 @@ pub(crate) struct Barrett {
 impl Barrett {
     /// # Arguments
     /// * `m` `1 <= m`
-    /// (Note: `m <= 2^31` should also hold, which is undocumented in the original library.
-    /// See the [pull reqeust commment](https://github.com/rust-lang-ja/ac-library-rs/pull/3#discussion_r484661007)
-    /// for more details.)
+    ///   (Note: `m <= 2^31` should also hold, which is undocumented in the original library.
+    ///   See the [pull reqeust commment](https://github.com/rust-lang-ja/ac-library-rs/pull/3#discussion_r484661007)
+    ///   for more details.)
     pub(crate) fn new(m: u32) -> Barrett {
         Barrett {
             _m: m,
@@ -208,7 +208,7 @@ pub(crate) fn primitive_root(m: i32) -> i32 {
     while x % 2 == 0 {
         x /= 2;
     }
-    for i in (3..std::i32::MAX).step_by(2) {
+    for i in (3..i32::MAX).step_by(2) {
         if i as i64 * i as i64 > x as i64 {
             break;
         }
@@ -328,55 +328,49 @@ mod tests {
         assert_eq!(pow_mod(0, 0, 3), 1);
         assert_eq!(pow_mod(0, 0, 723), 1);
         assert_eq!(pow_mod(0, 0, 998244353), 1);
-        assert_eq!(pow_mod(0, 0, i32::max_value()), 1);
+        assert_eq!(pow_mod(0, 0, i32::MAX), 1);
 
         assert_eq!(pow_mod(0, 1, 1), 0);
         assert_eq!(pow_mod(0, 1, 3), 0);
         assert_eq!(pow_mod(0, 1, 723), 0);
         assert_eq!(pow_mod(0, 1, 998244353), 0);
-        assert_eq!(pow_mod(0, 1, i32::max_value()), 0);
+        assert_eq!(pow_mod(0, 1, i32::MAX), 0);
 
-        assert_eq!(pow_mod(0, i64::max_value(), 1), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), 3), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), 723), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), 998244353), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), i32::max_value()), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 1), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 3), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 723), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 998244353), 0);
+        assert_eq!(pow_mod(0, i64::MAX, i32::MAX), 0);
 
         assert_eq!(pow_mod(1, 0, 1), 0);
         assert_eq!(pow_mod(1, 0, 3), 1);
         assert_eq!(pow_mod(1, 0, 723), 1);
         assert_eq!(pow_mod(1, 0, 998244353), 1);
-        assert_eq!(pow_mod(1, 0, i32::max_value()), 1);
+        assert_eq!(pow_mod(1, 0, i32::MAX), 1);
 
         assert_eq!(pow_mod(1, 1, 1), 0);
         assert_eq!(pow_mod(1, 1, 3), 1);
         assert_eq!(pow_mod(1, 1, 723), 1);
         assert_eq!(pow_mod(1, 1, 998244353), 1);
-        assert_eq!(pow_mod(1, 1, i32::max_value()), 1);
-
-        assert_eq!(pow_mod(1, i64::max_value(), 1), 0);
-        assert_eq!(pow_mod(1, i64::max_value(), 3), 1);
-        assert_eq!(pow_mod(1, i64::max_value(), 723), 1);
-        assert_eq!(pow_mod(1, i64::max_value(), 998244353), 1);
-        assert_eq!(pow_mod(1, i64::max_value(), i32::max_value()), 1);
-
-        assert_eq!(pow_mod(i64::max_value(), 0, 1), 0);
-        assert_eq!(pow_mod(i64::max_value(), 0, 3), 1);
-        assert_eq!(pow_mod(i64::max_value(), 0, 723), 1);
-        assert_eq!(pow_mod(i64::max_value(), 0, 998244353), 1);
-        assert_eq!(pow_mod(i64::max_value(), 0, i32::max_value()), 1);
-
-        assert_eq!(pow_mod(i64::max_value(), i64::max_value(), 1), 0);
-        assert_eq!(pow_mod(i64::max_value(), i64::max_value(), 3), 1);
-        assert_eq!(pow_mod(i64::max_value(), i64::max_value(), 723), 640);
-        assert_eq!(
-            pow_mod(i64::max_value(), i64::max_value(), 998244353),
-            683296792
-        );
-        assert_eq!(
-            pow_mod(i64::max_value(), i64::max_value(), i32::max_value()),
-            1
-        );
+        assert_eq!(pow_mod(1, 1, i32::MAX), 1);
+
+        assert_eq!(pow_mod(1, i64::MAX, 1), 0);
+        assert_eq!(pow_mod(1, i64::MAX, 3), 1);
+        assert_eq!(pow_mod(1, i64::MAX, 723), 1);
+        assert_eq!(pow_mod(1, i64::MAX, 998244353), 1);
+        assert_eq!(pow_mod(1, i64::MAX, i32::MAX), 1);
+
+        assert_eq!(pow_mod(i64::MAX, 0, 1), 0);
+        assert_eq!(pow_mod(i64::MAX, 0, 3), 1);
+        assert_eq!(pow_mod(i64::MAX, 0, 723), 1);
+        assert_eq!(pow_mod(i64::MAX, 0, 998244353), 1);
+        assert_eq!(pow_mod(i64::MAX, 0, i32::MAX), 1);
+
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 1), 0);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 3), 1);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 723), 640);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 998244353), 683296792);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, i32::MAX), 1);
 
         assert_eq!(pow_mod(2, 3, 1_000_000_007), 8);
         assert_eq!(pow_mod(5, 7, 1_000_000_007), 78125);
@@ -409,7 +403,7 @@ mod tests {
         assert!(!is_prime(1_000_000_000));
         assert!(is_prime(1_000_000_007));
 
-        assert!(is_prime(i32::max_value()));
+        assert!(is_prime(i32::MAX));
     }
 
     #[test]
@@ -442,8 +436,8 @@ mod tests {
             (57, 81, 3),
             (12345, 67890, 15),
             (-3141592 * 6535, 3141592 * 8979, 3141592),
-            (i64::max_value(), i64::max_value(), i64::max_value()),
-            (i64::min_value(), i64::max_value(), 1),
+            (i64::MAX, i64::MAX, i64::MAX),
+            (i64::MIN, i64::MAX, 1),
         ] {
             let (g_, x) = inv_gcd(a, b);
             assert_eq!(g, g_);
@@ -454,17 +448,7 @@ mod tests {
 
     #[test]
     fn test_primitive_root() {
-        for &p in &[
-            2,
-            3,
-            5,
-            7,
-            233,
-            200003,
-            998244353,
-            1_000_000_007,
-            i32::max_value(),
-        ] {
+        for &p in &[2, 3, 5, 7, 233, 200003, 998244353, 1_000_000_007, i32::MAX] {
             assert!(is_prime(p));
             let g = primitive_root(p);
             if p != 2 {
@@ -472,7 +456,7 @@ mod tests {
             }
 
             let q = p - 1;
-            for i in (2..i32::max_value()).take_while(|i| i * i <= q) {
+            for i in (2..i32::MAX).take_while(|i| i * i <= q) {
                 if q % i != 0 {
                     break;
                 }
diff --git a/src/internal_type_traits.rs b/src/internal_type_traits.rs
index 88a52a9..5761161 100644
--- a/src/internal_type_traits.rs
+++ b/src/internal_type_traits.rs
@@ -99,14 +99,14 @@ macro_rules! impl_integral {
             impl BoundedBelow for $ty {
                 #[inline]
                 fn min_value() -> Self {
-                    Self::min_value()
+                    Self::MIN
                 }
             }
 
             impl BoundedAbove for $ty {
                 #[inline]
                 fn max_value() -> Self {
-                    Self::max_value()
+                    Self::MAX
                 }
             }
 
diff --git a/src/lazysegtree.rs b/src/lazysegtree.rs
index d430b34..53e9487 100644
--- a/src/lazysegtree.rs
+++ b/src/lazysegtree.rs
@@ -382,7 +382,7 @@ mod tests {
         check_segtree(&base, &mut segtree);
 
         let mut segtree = LazySegtree::<MaxAdd>::new(n);
-        let mut internal = vec![i32::min_value(); n];
+        let mut internal = vec![i32::MIN; n];
         for i in 0..n {
             segtree.set(i, base[i]);
             internal[i] = base[i];
@@ -435,7 +435,7 @@ mod tests {
         }
         assert_eq!(
             segtree.all_prod(),
-            base.iter().max().copied().unwrap_or(i32::min_value())
+            base.iter().max().copied().unwrap_or(i32::MIN)
         );
         for k in 0..=10 {
             let f = |x| x < k;
@@ -443,11 +443,7 @@ mod tests {
                 assert_eq!(
                     Some(segtree.max_right(i, f)),
                     (i..=n)
-                        .filter(|&j| f(base[i..j]
-                            .iter()
-                            .max()
-                            .copied()
-                            .unwrap_or(i32::min_value())))
+                        .filter(|&j| f(base[i..j].iter().max().copied().unwrap_or(i32::MIN)))
                         .max()
                 );
             }
@@ -455,11 +451,7 @@ mod tests {
                 assert_eq!(
                     Some(segtree.min_left(j, f)),
                     (0..=j)
-                        .filter(|&i| f(base[i..j]
-                            .iter()
-                            .max()
-                            .copied()
-                            .unwrap_or(i32::min_value())))
+                        .filter(|&i| f(base[i..j].iter().max().copied().unwrap_or(i32::MIN)))
                         .min()
                 );
             }
@@ -473,7 +465,7 @@ mod tests {
             .filter_map(|(i, a)| Some(a).filter(|_| range.contains(&i)))
             .max()
             .copied()
-            .unwrap_or(i32::min_value());
+            .unwrap_or(i32::MIN);
         assert_eq!(segtree.prod(range), expected);
     }
 }
diff --git a/src/math.rs b/src/math.rs
index 26cdd86..df3aa8d 100644
--- a/src/math.rs
+++ b/src/math.rs
@@ -228,11 +228,11 @@ mod tests {
         assert_eq!(pow_mod(0, 1, 998244353), 0);
         assert_eq!(pow_mod(0, 1, 2u32.pow(31)), 0);
 
-        assert_eq!(pow_mod(0, i64::max_value(), 1), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), 3), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), 723), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), 998244353), 0);
-        assert_eq!(pow_mod(0, i64::max_value(), 2u32.pow(31)), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 1), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 3), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 723), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 998244353), 0);
+        assert_eq!(pow_mod(0, i64::MAX, 2u32.pow(31)), 0);
 
         assert_eq!(pow_mod(1, 0, 1), 0);
         assert_eq!(pow_mod(1, 0, 3), 1);
@@ -246,29 +246,23 @@ mod tests {
         assert_eq!(pow_mod(1, 1, 998244353), 1);
         assert_eq!(pow_mod(1, 1, 2u32.pow(31)), 1);
 
-        assert_eq!(pow_mod(1, i64::max_value(), 1), 0);
-        assert_eq!(pow_mod(1, i64::max_value(), 3), 1);
-        assert_eq!(pow_mod(1, i64::max_value(), 723), 1);
-        assert_eq!(pow_mod(1, i64::max_value(), 998244353), 1);
-        assert_eq!(pow_mod(1, i64::max_value(), 2u32.pow(31)), 1);
+        assert_eq!(pow_mod(1, i64::MAX, 1), 0);
+        assert_eq!(pow_mod(1, i64::MAX, 3), 1);
+        assert_eq!(pow_mod(1, i64::MAX, 723), 1);
+        assert_eq!(pow_mod(1, i64::MAX, 998244353), 1);
+        assert_eq!(pow_mod(1, i64::MAX, 2u32.pow(31)), 1);
 
-        assert_eq!(pow_mod(i64::max_value(), 0, 1), 0);
-        assert_eq!(pow_mod(i64::max_value(), 0, 3), 1);
-        assert_eq!(pow_mod(i64::max_value(), 0, 723), 1);
-        assert_eq!(pow_mod(i64::max_value(), 0, 998244353), 1);
-        assert_eq!(pow_mod(i64::max_value(), 0, 2u32.pow(31)), 1);
+        assert_eq!(pow_mod(i64::MAX, 0, 1), 0);
+        assert_eq!(pow_mod(i64::MAX, 0, 3), 1);
+        assert_eq!(pow_mod(i64::MAX, 0, 723), 1);
+        assert_eq!(pow_mod(i64::MAX, 0, 998244353), 1);
+        assert_eq!(pow_mod(i64::MAX, 0, 2u32.pow(31)), 1);
 
-        assert_eq!(pow_mod(i64::max_value(), i64::max_value(), 1), 0);
-        assert_eq!(pow_mod(i64::max_value(), i64::max_value(), 3), 1);
-        assert_eq!(pow_mod(i64::max_value(), i64::max_value(), 723), 640);
-        assert_eq!(
-            pow_mod(i64::max_value(), i64::max_value(), 998244353),
-            683296792
-        );
-        assert_eq!(
-            pow_mod(i64::max_value(), i64::max_value(), 2u32.pow(31)),
-            2147483647
-        );
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 1), 0);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 3), 1);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 723), 640);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 998244353), 683296792);
+        assert_eq!(pow_mod(i64::MAX, i64::MAX, 2u32.pow(31)), 2147483647);
 
         assert_eq!(pow_mod(2, 3, 1_000_000_007), 8);
         assert_eq!(pow_mod(5, 7, 1_000_000_007), 78125);
diff --git a/src/mincostflow.rs b/src/mincostflow.rs
index 7d708e4..d8e2c71 100644
--- a/src/mincostflow.rs
+++ b/src/mincostflow.rs
@@ -204,7 +204,7 @@ mod tests {
         assert_eq!(1, graph.add_edge(1, 2, 1, 0));
         assert_eq!(2, graph.add_edge(0, 2, 2, 1));
         let expected = [(0, 0), (3, 3)];
-        assert_eq!(expected[..], *graph.slope(0, 2, i32::max_value()));
+        assert_eq!(expected[..], *graph.slope(0, 2, i32::MAX));
     }
 
     #[test]
@@ -213,6 +213,6 @@ mod tests {
         assert_eq!(0, graph.add_edge(0, 1, 1, 1));
         assert_eq!(1, graph.add_edge(1, 2, 1, 0));
         let expected = [(0, 0), (1, 1)];
-        assert_eq!(expected[..], *graph.slope(0, 2, i32::max_value()));
+        assert_eq!(expected[..], *graph.slope(0, 2, i32::MAX));
     }
 }
diff --git a/src/modint.rs b/src/modint.rs
index 022263c..555a338 100644
--- a/src/modint.rs
+++ b/src/modint.rs
@@ -858,7 +858,7 @@ macro_rules! impl_basic_traits {
             }
         }
 
-        #[allow(clippy::derive_hash_xor_eq)]
+        #[allow(clippy::derived_hash_with_manual_eq)]
         impl<$generic_param: $generic_param_bound> Hash for $self {
             #[inline]
             fn hash<H: Hasher>(&self, state: &mut H) {
diff --git a/src/segtree.rs b/src/segtree.rs
index e79c74e..fc7a4c2 100644
--- a/src/segtree.rs
+++ b/src/segtree.rs
@@ -337,7 +337,7 @@ mod tests {
         check_segtree(&base, &segtree);
 
         let mut segtree = Segtree::<Max<_>>::new(n);
-        let mut internal = vec![i32::min_value(); n];
+        let mut internal = vec![i32::MIN; n];
         for i in 0..n {
             segtree.set(i, base[i]);
             internal[i] = base[i];
@@ -378,7 +378,7 @@ mod tests {
         }
         assert_eq!(
             segtree.all_prod(),
-            base.iter().max().copied().unwrap_or(i32::min_value())
+            base.iter().max().copied().unwrap_or(i32::MAX)
         );
         for k in 0..=10 {
             let f = |&x: &i32| x < k;
@@ -386,11 +386,7 @@ mod tests {
                 assert_eq!(
                     Some(segtree.max_right(i, f)),
                     (i..=n)
-                        .filter(|&j| f(&base[i..j]
-                            .iter()
-                            .max()
-                            .copied()
-                            .unwrap_or(i32::min_value())))
+                        .filter(|&j| f(&base[i..j].iter().max().copied().unwrap_or(i32::MIN)))
                         .max()
                 );
             }
@@ -398,11 +394,7 @@ mod tests {
                 assert_eq!(
                     Some(segtree.min_left(j, f)),
                     (0..=j)
-                        .filter(|&i| f(&base[i..j]
-                            .iter()
-                            .max()
-                            .copied()
-                            .unwrap_or(i32::min_value())))
+                        .filter(|&i| f(&base[i..j].iter().max().copied().unwrap_or(i32::MIN)))
                         .min()
                 );
             }
@@ -416,7 +408,7 @@ mod tests {
             .filter_map(|(i, a)| Some(a).filter(|_| range.contains(&i)))
             .max()
             .copied()
-            .unwrap_or(i32::min_value());
+            .unwrap_or(i32::MIN);
         assert_eq!(segtree.prod(range), expected);
     }
 }
diff --git a/src/twosat.rs b/src/twosat.rs
index 856ace0..8ab7672 100644
--- a/src/twosat.rs
+++ b/src/twosat.rs
@@ -163,7 +163,7 @@ mod tests {
 
         //Check the min distance between flags
         res.sort_unstable();
-        let mut min_distance = i32::max_value();
+        let mut min_distance = i32::MAX;
         for i in 1..res.len() {
             min_distance = std::cmp::min(min_distance, res[i] - res[i - 1]);
         }