proconlib

Library Files

tools/

• std::abs(x) extended for my library (tools/abs.hpp)
• Alphabetical order of a given character (tools/alphabetical_order.hpp)
• Bitwise AND convolution (tools/and_convolution.hpp)
• Concept for arithmetic types including tools::int128_t and tools::uint128_t (tools/arithmetic.hpp)
• Assertion macro (tools/assert_that.hpp)
• Auxiliary tree (tools/auxiliary_tree.hpp)
• Concept for a type that can be passed for range adaptors multi times (tools/available_for_multiple_range_adaptors.hpp)
• Reversible self-balancing binary search tree based on AVL tree (tools/avl_tree.hpp)
• Bell numbers (tools/bell.hpp)
• Bellman-Ford algorithm (tools/bellman_ford.hpp)
• Berlekamp-Massey algorithm (tools/berlekamp_massey.hpp)
• Bernoulli numbers $B_k \pmod{P}$ for $0 \leq k \leq n$ (tools/bernoulli.hpp)
• Bézout's identity (tools/bezout.hpp)
• Arbitrary precision floating-point number (tools/bigdecimal.hpp)
• Arbitrary precision integer (tools/bigint.hpp)
• Binary heap (tools/binary_heap.hpp)
• $\prod_{i = 0}^{m - 1} (a_i + b_i x^{c_i})^{d_i}$ (tools/binomial_product.hpp)
• Matching on bipartite graph (tools/bipartite_matching.hpp)
• $2^{\left\lceil \log_2(x) \right\rceil}$ (tools/bit_ceil.hpp)
• $2^{\left\lfloor \log_2(x) \right\rfloor}$ (tools/bit_floor.hpp)
• Bit vector (tools/bit_vector.hpp)
• Bit width required to represent a given integer (tools/bit_width.hpp)
• $\left\lceil \frac{x}{y} \right\rceil y$ (tools/block_ceil.hpp)
• $\left\lfloor \frac{x}{y} \right\rfloor y$ (tools/block_floor.hpp)
• Bostan-Mori algorithm (tools/bostan_mori.hpp)
• Cartesian tree (tools/cartesian_tree.hpp)
• Counter clockwise function (tools/ccw.hpp)
• $\left\lceil \frac{x}{y} \right\rceil$ (tools/ceil.hpp)
• $\left\lceil x^\frac{1}{k} \right\rceil$ (tools/ceil_kth_root.hpp)
• $\left\lceil \log_b(x) \right\rceil$ (tools/ceil_log.hpp)
• $\left\lceil \log_2(x) \right\rceil$ (tools/ceil_log2.hpp)
• Enumerate the range of $\left\lceil \frac{A}{x} \right\rceil$ (tools/ceil_quotients.hpp)
• $\left\lceil \sqrt{x} \right\rceil$ (tools/ceil_sqrt.hpp)
• chmax function (tools/chmax.hpp)
• chmin function (tools/chmin.hpp)
• Chromatic number (tools/chromatic_number.hpp)
• Fast input (tools/cin.hpp)
• Two-dimensional circle (tools/circle_2d.hpp)
• Two-dimensional circumcircle (tools/circumcircle_2d.hpp)
• std::cmp_equal extended for my library (tools/cmp_equal.hpp)
• std::cmp_greater extended for my library (tools/cmp_greater.hpp)
• std::cmp_greater_equal extended for my library (tools/cmp_greater_equal.hpp)
• std::cmp_less extended for my library (tools/cmp_less.hpp)
• std::cmp_less_equal extended for my library (tools/cmp_less_equal.hpp)
• std::cmp_not_equal extended for my library (tools/cmp_not_equal.hpp)
• Concept for commutative group (tools/commutative_group.hpp)
• Concept for commutative monoid (tools/commutative_monoid.hpp)
• Concept for commutative ring (tools/commutative_ring.hpp)
• Concept for std::complex (tools/complex.hpp)
• In-place coordinate compression (tools/compress.hpp)
• Coordinate compression (tools/compressed.hpp)
• Compress values (for more complicated cases) (tools/compressor.hpp)
• Convex hull (tools/convex_hull.hpp)
• Convolution (tools/convolution.hpp)
• Number of trailing zeros (tools/countr_zero.hpp)
• Fast output (tools/cout.hpp)
• 2D cumulative sum (tools/cumsum2d.hpp)
• Cycle detection on a graph (tools/cycle_detection.hpp)
• Frequency table of digit products (tools/digit_product_frequency.hpp)
• Sum of digits (tools/digit_sum.hpp)
• Dijkstra's algorithm (tools/dijkstra.hpp)
• Two-dimensional directed line segment (tools/directed_line_segment_2d.hpp)
• Disjoint sparse table (tools/disjoint_sparse_table.hpp)
• 2D disjoint sparse table (tools/disjoint_sparse_table_2d.hpp)
• Divisor Möbius transform (tools/divisor_moebius.hpp)
• In-place divisor Möbius transform (tools/divisor_moebius_inplace.hpp)
• Divisor Zeta transform (tools/divisor_zeta.hpp)
• In-place divisor Zeta transform (tools/divisor_zeta_inplace.hpp)
• List all positive divisors (tools/divisors.hpp)
• List all divisors of a divisor of $n$ (tools/divisors_of_divisor.hpp)
• Disjoint set union (tools/dsu.hpp)
• Dual segment tree (tools/dual_segtree.hpp)
• Dual sparse segment tree (tools/dual_sparse_segtree.hpp)
• std::bitset with dynamic size (tools/dynamic_bitset.hpp)
• Sieve of Eratosthenes (tools/eratosthenes_sieve.hpp)
• std::exp(x) extended for my library (tools/exp.hpp)
• Extend std::hash (tools/extend_hash.hpp)
• Extend operator>> (tools/extend_input.hpp)
• Extend operator<< (tools/extend_output.hpp)
• Extended Garner's algorithm (tools/extended_garner.hpp)
• Extended Lucas' theorem (tools/extended_lucas.hpp)
• Extended Euclidean algorithm (tools/extgcd.hpp)
• Cache for $n^{-1}, n!, n!^{-1} \pmod{P}$ (tools/fact_mod_cache.hpp)
• Formal Dirichlet series with prefix sums (tools/fds_with_prefix_sums.hpp)
• Concept for field (tools/field.hpp)
• Typical fields (tools/fields.hpp)
• Fill a multi-dimensional vector (tools/fill.hpp)
• Floyd's cycle-finding algorithm (tools/find_cycle.hpp)
• Fixed point combinator (tools/fix.hpp)
• $\left\lfloor \frac{x}{y} \right\rfloor$ (tools/floor.hpp)
• $\left\lfloor x^\frac{1}{k} \right\rfloor$ (tools/floor_kth_root.hpp)
• $\left\lfloor \log_b(x) \right\rfloor$ (tools/floor_log.hpp)
• $\left\lfloor \log_2(x) \right\rfloor$ (tools/floor_log2.hpp)
• Enumerate the range of $\left\lfloor \frac{A}{x} \right\rfloor$ (tools/floor_quotients.hpp)
• $\left\lfloor \sqrt{x} \right\rfloor$ (tools/floor_sqrt.hpp)
• Formal power series (tools/fps.hpp)
• Garner's algorithm (tools/garner.hpp)
• Garner's algorithm for $\mathbb{Z} / M_1 \mathbb{Z}$ and $\mathbb{Z} / M_2 \mathbb{Z}$ (tools/garner2.hpp)
• Garner's algorithm for $\mathbb{Z} / M_1 \mathbb{Z}$, $\mathbb{Z} / M_2 \mathbb{Z}$ and $\mathbb{Z} / M_3 \mathbb{Z}$ (tools/garner3.hpp)
• std::gcd(m, n) extended for my library (tools/gcd.hpp)
• GCD convolution (tools/gcd_convolution.hpp)
• Return type of read-only getter (tools/getter_result.hpp)
• Golden section search (tools/golden_section_search.hpp)
• std::greater by key (tools/greater_by.hpp)
• std::greater by the argument (tools/greater_by_arg.hpp)
• std::greater by the argument (total order) (tools/greater_by_arg_total.hpp)
• std::greater by first (tools/greater_by_first.hpp)
• std::greater by std::get (tools/greater_by_get.hpp)
• std::greater by second (tools/greater_by_second.hpp)
• Find $a$ from $b$ when $b_i = \sum_{j = i}^{N - 1} a_j$ holds (tools/greater_equal_moebius.hpp)
• Update $b$ to $a$ such that $b_i = \sum_{j = i}^{N - 1} a_j$ holds (tools/greater_equal_moebius_inplace.hpp)
• Find $b$ from $a$ when $b_i = \sum_{j = i}^{N - 1} a_j$ holds (tools/greater_equal_zeta.hpp)
• Update $a$ to $b$ such that $b_i = \sum_{j = i}^{N - 1} a_j$ holds (tools/greater_equal_zeta_inplace.hpp)
• Concept for group (tools/group.hpp)
• Typical groups (tools/groups.hpp)
• Two-dimensional half line (tools/half_line_2d.hpp)
• Check whether a given integer is $2^n$ (tools/has_single_bit.hpp)
• Combine hash values (tools/hash_combine.hpp)
• Heavy-light decomposition (tools/hld.hpp)
• 128-bit signed integer (tools/int128_t.hpp)
• Set of integers as closed integer intervals (tools/integer_interval_set.hpp)
• Concept for integral types including tools::int128_t and tools::uint128_t (tools/integral.hpp)
• $x^{-1} \pmod{M}$ (tools/inv_mod.hpp)
• The number of inversions (tools/inversion_number.hpp)
• Check whether a given graph is bipartite (tools/is_bipartite.hpp)
• Check whether $(r, c)$ is in a grid of height $h$ and width $w$ (tools/is_in_grid.hpp)
• std::is_integral extended for tools::int128_t and tools::uint128_t (tools/is_integral.hpp)
• Check whether a given boolean function is partitioned (tools/is_partitioned.hpp)
• Miller-Rabin primality test (tools/is_prime.hpp)
• Check whether T is a range type (tools/is_range.hpp)
• Check whether T is tools::rational (tools/is_rational.hpp)
• std::is_signed extended for tools::int128_t and tools::uint128_t (tools/is_signed.hpp)
• std::is_unsigned extended for tools::int128_t and tools::uint128_t (tools/is_unsigned.hpp)
• Join elements with delimiter (tools/join.hpp)
• Find the k-th largest integer using oracle (tools/kth_largest_by_oracle.hpp)
• Find the k-th smallest integer using oracle (tools/kth_smallest_by_oracle.hpp)
• Precompute $n! \pmod{P}$ for $0 \leq n < P \approx 10^9$ (tools/large_fact_mod_cache.hpp)
• Largest rectangle in histogram (tools/largest_rectangle_in_histogram.hpp)
• Lazy reversible self-balancing binary search tree based on AVL tree (tools/lazy_avl_tree.hpp)
• Segment tree with lazy propagation (tools/lazy_segtree.hpp)
• Sparse segment tree with lazy propagation (tools/lazy_sparse_segtree.hpp)
• Lowest common ancestor (tools/lca.hpp)
• LCM convolution (tools/lcm_convolution.hpp)
• std::less by key (tools/less_by.hpp)
• std::less by the argument (tools/less_by_arg.hpp)
• std::less by the argument (total order) (tools/less_by_arg_total.hpp)
• std::less by first (tools/less_by_first.hpp)
• std::less by std::get (tools/less_by_get.hpp)
• std::less by second (tools/less_by_second.hpp)
• Find $a$ from $b$ when $b_i = \sum_{j = 0}^i a_j$ holds (tools/less_equal_moebius.hpp)
• Update $b$ to $a$ such that $b_i = \sum_{j = 0}^i a_j$ holds (tools/less_equal_moebius_inplace.hpp)
• Find $b$ from $a$ when $b_i = \sum_{j = 0}^i a_j$ holds (tools/less_equal_zeta.hpp)
• Update $a$ to $b$ such that $b_i = \sum_{j = 0}^i a_j$ holds (tools/less_equal_zeta_inplace.hpp)
• Li Chao segment tree (tools/li_chao_segtree.hpp)
• Two-dimensional line (tools/line_2d.hpp)
• Linear sieve (tools/linear_sieve.hpp)
• Longest increasing subsequence (tools/lis.hpp)
• std::log(x) extended for my library (tools/log.hpp)
• $\log_x y \pmod{M}$ (tools/log_mod.hpp)
• Multiset $S$ such that $\{\sum_{x \in S'} x | S' \subseteq S\} = \{0, 1, \ldots, N\}$ and $|S| = O(\log N)$ (tools/logn_integer_partition.hpp)
• Longest common substring (tools/longest_common_substring.hpp)
• std::ranges::lower_bound, but returns index (tools/lower_bound.hpp)
• Lowlink (tools/lowlink.hpp)
• std::make_signed extended for tools::int128_t and tools::uint128_t (tools/make_signed.hpp)
• std::make_unsigned extended for tools::int128_t and tools::uint128_t (tools/make_unsigned.hpp)
• Wider integral type (tools/make_wider.hpp)
• Manacher (tools/manacher.hpp)
• Matrix (tools/matrix.hpp)
• tools/matrix_mod2.hpp
• Maximum matching on general graph (tools/max_matching.hpp)
• Solver of minimum-cost flow problem (tools/mcf_graph.hpp)
• Heap managing median (tools/median_heap.hpp)
• Minimum excluded value (tools/mex.hpp)
• std::midpoint(a, b) extended for my library (tools/midpoint.hpp)
• Minimum Steiner tree (tools/minimum_steiner_tree.hpp)
• Mo's algorithm (tools/mo.hpp)
• Minimum non-negative reminder (tools/mod.hpp)
• Concept for atcoder::static_modint and atcoder::dynamic_modint (tools/modint.hpp)
• Concept for a type compatible with atcoder::static_modint (tools/modint_compatible.hpp)
• $\mathbb{Z} / (2^{61} - 1) \mathbb{Z}$ (tools/modint_for_rolling_hash.hpp)
• Concept for monoid (tools/monoid.hpp)
• Typical monoids (tools/monoids.hpp)
• Multiple Möbius transform (tools/multiple_moebius.hpp)
• In-place multiple Möbius transform (tools/multiple_moebius_inplace.hpp)
• Multiple Zeta transform (tools/multiple_zeta.hpp)
• In-place multiple Zeta transform (tools/multiple_zeta_inplace.hpp)
• Automatically deduced multiplicative structure (tools/multiplicative_structure.hpp)
• __gnu_pbds::tree, but it allows duplication (tools/multiset.hpp)
• Sort multiple arrays at once (tools/multisort.hpp)
• Multivariate convolution (tools/multivariate_convolution.hpp)
• Concept for a mutable type (tools/mutable_type.hpp)
• Dijkstra's algorithm for dense graph (tools/naive_dijkstra.hpp)
• Next combination as n-choose-r (tools/next_combination.hpp)
• Enumerate all integer partitions (tools/next_integer_partition.hpp)
• Enumerate all matchings (tools/next_matching.hpp)
• Next permutation as n-choose-r (tools/next_permutation.hpp)
• tools::integral except for bool (tools/non_bool_integral.hpp)
• Dummy mapping (tools/nop_mapping.hpp)
• Dummy monoid (tools/nop_monoid.hpp)
• The number of nanoseconds that have elapsed since epoch (tools/now.hpp)
• Online cumulative sum (tools/online_cumsum.hpp)
• Online difference array (tools/online_imos.hpp)
• Bitwise OR convolution (tools/or_convolution.hpp)
• $\mathrm{ord}(x)$ for $x \in (\mathbb{Z}/p\mathbb{Z})^\times$ (tools/ord_mod.hpp)
• Partially persistent disjoint set union (tools/partially_persistent_dsu.hpp)
• Partition function (tools/partition_function.hpp)
• Potentialized disjoint set union (tools/pdsu.hpp)
• Permutation (tools/permutation.hpp)
• Persistent array (tools/persistent_array.hpp)
• Persistent dual segment tree (tools/persistent_dual_segtree.hpp)
• Persistent segment tree with lazy propagation (tools/persistent_lazy_segtree.hpp)
• Persistent queue (tools/persistent_queue.hpp)
• Persistent segment tree (tools/persistent_segtree.hpp)
• Persistent stack (tools/persistent_stack.hpp)
• Two-dimensional polygon (tools/polygon_2d.hpp)
• Polynomial (tools/polynomial.hpp)
• Polynomial interpolation (tools/polynomial_interpolation.hpp)
• Product of polynomials (tools/polynomial_product.hpp)
• Popcount (tools/popcount.hpp)
• $b^n$ under a given monoid, and std::pow(b, n) extended for my library (tools/pow.hpp)
• $2^x$ (tools/pow2.hpp)
• $x^y \pmod{M}$ (tools/pow_mod.hpp)
• Cache for $b^n \pmod{M}$ (tools/pow_mod_cache.hpp)
• tools/preset_segtree_beats.hpp
• Preset wavelet matrix (tools/preset_wavelet_matrix.hpp)
• Prim's algorithm (tools/prim.hpp)
• Pollard's rho algorithm (tools/prime_factorization.hpp)
• Concept for atcoder::static_modint such that its modulo is a prime (tools/prime_static_modint.hpp)
• Primitive root (tools/primitive_root.hpp)
• $x \cdot y \pmod{M}$ (tools/prod_mod.hpp)
• QCFium's method (tools/qcfium.hpp)
• Quaternion (tools/quaternion.hpp)
• Quotient as integer division (tools/quo.hpp)
• Random tree generator (tools/random_tree.hpp)
• Range count distinct (tools/range_count_distinct.hpp)
• Disjoint set union, but allows range parallel union (tools/range_parallel_dsu.hpp)
• Rational number (tools/rational.hpp)
• Rational binary search (tools/rational_binary_search.hpp)
• Set of real numbers as closed integer intervals (tools/real_interval_set.hpp)
• Area of union of rectangles (tools/rectangle_union_area.hpp)
• Dynamic programming on a tree with rerooting technique (tools/rerooting_dp.hpp)
• Resize a multi-dimensional vector (tools/resize.hpp)
• Bit reverse (tools/reverse.hpp)
• Concept for ring (tools/ring.hpp)
• Typical rings (tools/rings.hpp)
• Rolling hash (tools/rolling_hash.hpp)
• Alias for __gnu_cxx::rope (tools/rope.hpp)
• Circular shift to the left / Rotate a given matrix 90 degrees to the left (tools/rotl.hpp)
• Circular shift to the right / Rotate a given matrix 90 degrees to the right (tools/rotr.hpp)
• Rounding mode (tools/rounding_mode.hpp)
• Run-length encoding (tools/run_length.hpp)
• $\mathbb{Z} \cup \{\infty, -\infty, \mathrm{NaN}\}$ and $\mathbb{Z}_{\geq 0} \cup \{\infty, \mathrm{NaN}\}$ (tools/safe_int.hpp)
• Shift of sampling points of polynomial (tools/sample_point_shift.hpp)
• Strongly connected component decomposition (tools/scc_graph.hpp)
• Second-order difference array (tools/second_order_imos.hpp)
• Segmented sieve (tools/segmented_sieve.hpp)
• tools/segtree_beats.hpp
• Concept for semiring (tools/semiring.hpp)
• Typical semirings (tools/semirings.hpp)
• __gnu_pbds::tree, but more compatible with std::set (tools/set.hpp)
• Shortest path tree (tools/shortest_path_tree.hpp)
• Concept for signed integral types including tools::int128_t (tools/signed_integral.hpp)
• Sign function (tools/signum.hpp)
• std::lower_bound in $\left\langle O(N + \max(A_i) - \min(A_i)), O(1) \right\rangle$ time (tools/small_range_lower_bound.hpp)
• Power of a sparse FPS (tools/sparse_fps_pow.hpp)
• Sparse segment tree (tools/sparse_segtree.hpp)
• Concept for the specialized type of U (tools/specialization_of.hpp)
• $\sqrt{x} \pmod{P}$ (tools/sqrt_mod.hpp)
• $x^2$ under a given monoid (tools/square.hpp)
• Stern–Brocot tree (tools/stern_brocot_tree.hpp)
• Signed Stirling numbers of the first kind (tools/stirling_1st.hpp)
• Stirling numbers of the second kind (tools/stirling_2nd.hpp)
• Subset convolution (tools/subset_convolution.hpp)
• Subset Möbius transform (tools/subset_moebius.hpp)
• In-place subset Möbius transform (tools/subset_moebius_inplace.hpp)
• Subset sum (tools/subset_sum.hpp)
• Subset Zeta transform (tools/subset_zeta.hpp)
• In-place subset Zeta transform (tools/subset_zeta_inplace.hpp)
• Wrapper of atcoder::suffix_array and atcoder::lcp_array (tools/suffix_array.hpp)
• Superset Möbius transform (tools/superset_moebius.hpp)
• In-place superset Möbius transform (tools/superset_moebius_inplace.hpp)
• Superset Zeta transform (tools/superset_zeta.hpp)
• In-place superset Zeta transform (tools/superset_zeta_inplace.hpp)
• Sliding window aggregation (tools/swag.hpp)
• $x \uparrow\uparrow y \pmod{M}$ (tools/tetration_mod.hpp)
• Euler's totient function (tools/totient.hpp)
• Transposition (tools/transposed.hpp)
• Diameter of a tree (tools/tree_diameter.hpp)
• Two-dimensional triangle (tools/triangle_2d.hpp)
• Triangular array (tools/triangular_array.hpp)
• One-to-one mapping from a triangular array to a one-dimensional array (tools/triangular_array_compressor.hpp)
• Topological sorting (tools/tsort.hpp)
• Traveling salesman problem (tools/tsp.hpp)
• Hash of std::tuple (tools/tuple_hash.hpp)
• Twelvefold way (tools/twelvefold_way.hpp)
• 128-bit unsigned integer (tools/uint128_t.hpp)
• Undoable disjoint set union (tools/undoable_dsu.hpp)
• Alias for __gnu_pbds::gp_hash_table<Key, T, Hash> (tools/unordered_map.hpp)
• Alias for __gnu_pbds::gp_hash_table<Key, __gnu_pbds::null_type, Hash> (tools/unordered_set.hpp)
• Concept for unsigned integral types including tools::uint128_t (tools/unsigned_integral.hpp)
• std::ranges::upper_bound, but returns index (tools/upper_bound.hpp)
• Commonly used utilities for competitive programming (tools/util.hpp)
• Vector (tools/vector.hpp)
• Two dimensional vector (tools/vector2.hpp)
• Three dimensional vector (tools/vector3.hpp)
• Four dimensional vector (tools/vector4.hpp)
• Wavelet matrix (tools/wavelet_matrix.hpp)
• Matching on weighted bipartite graph (tools/weighted_bipartite_matching.hpp)
• Basis of xor (tools/xor_basis.hpp)
• Bitwise XOR convolution (tools/xor_convolution.hpp)
• 01-BFS (tools/zero_one_bfs.hpp)
• 0-1 knapsack problem (tools/zero_one_knapsack.hpp)

tools/detail/

• tools/detail/avl_tree_impl.hpp
• tools/detail/geometry_2d.hpp
• tools/detail/int128_t_and_uint128_t.hpp
• tools/detail/interval_set.hpp
• tools/detail/kth_largest_by_oracle.hpp
• tools/detail/rolling_hash.hpp

Verification Files

tests/

• tests/alphabetical_order.test.cpp
• tests/and_convolution.test.cpp
• tests/arithmetic.test.cpp
• tests/auxiliary_tree.test.cpp
• tests/bellman_ford.test.cpp
• tests/berlekamp_massey.test.cpp
• tests/bernoulli.test.cpp
• tests/bezout.test.cpp
• tests/binary_heap.test.cpp
• tests/bipartite_matching.test.cpp
• tests/bit_ceil.test.cpp
• tests/bit_floor.test.cpp
• tests/bit_width.test.cpp
• tests/block_ceil.test.cpp
• tests/block_floor.test.cpp
• tests/bostan_mori.test.cpp
• tests/ccw.test.cpp
• tests/ceil.test.cpp
• tests/ceil_kth_root.test.cpp
• tests/ceil_log.test.cpp
• tests/ceil_log2.test.cpp
• tests/ceil_quotients.test.cpp
• tests/ceil_sqrt.test.cpp
• tests/chromatic_number.test.cpp
• tests/cmp_equal.test.cpp
• tests/cmp_greater.test.cpp
• tests/cmp_greater_equal.test.cpp
• tests/cmp_less.test.cpp
• tests/cmp_less_equal.test.cpp
• tests/cmp_not_equal.test.cpp
• tests/complex.test.cpp
• tests/compressor.test.cpp
• tests/convex_hull.test.cpp
• tests/countr_zero.test.cpp
• tests/cumsum2d.test.cpp
• tests/digit_product_frequency.test.cpp
• tests/digit_sum.test.cpp
• tests/disjoint_sparse_table.test.cpp
• tests/disjoint_sparse_table_2d.test.cpp
• tests/divisor_moebius.test.cpp
• tests/divisor_zeta.test.cpp
• tests/divisors.test.cpp
• tests/divisors_of_divisor.test.cpp
• tests/dsu.test.cpp
• tests/dual_segtree.test.cpp
• tests/dual_sparse_segtree.test.cpp
• tests/eratosthenes_sieve.test.cpp
• tests/extend_hash.test.cpp
• tests/extend_input.test.cpp
• tests/extend_output.test.cpp
• tests/extended_garner.test.cpp
• tests/extended_lucas.test.cpp
• tests/extgcd.test.cpp
• tests/fact_mod_cache.test.cpp
• tests/fill.test.cpp
• tests/find_cycle.test.cpp
• tests/fix.test.cpp
• tests/floor.test.cpp
• tests/floor_kth_root.test.cpp
• tests/floor_log.test.cpp
• tests/floor_log2.test.cpp
• tests/floor_quotients.test.cpp
• tests/floor_sqrt.test.cpp
• tests/gcd.test.cpp
• tests/getter_result.test.cpp
• tests/golden_section_search.test.cpp
• tests/greater_by_arg.test.cpp
• tests/greater_by_arg_total.test.cpp
• tests/greater_equal_moebius.test.cpp
• tests/greater_equal_zeta.test.cpp
• tests/group.test.cpp
• tests/groups.test.cpp
• tests/int128_t.test.cpp
• tests/integer_interval_set.test.cpp
• tests/integral.test.cpp
• tests/inversion_number.test.cpp
• tests/is_bipartite.test.cpp
• tests/is_in_grid.test.cpp
• tests/is_integral.test.cpp
• tests/is_partitioned.test.cpp
• tests/is_prime.test.cpp
• tests/is_signed.test.cpp
• tests/is_unsigned.test.cpp
• tests/kth_largest_by_oracle.test.cpp
• tests/kth_smallest_by_oracle.test.cpp
• tests/largest_rectangle_in_histogram.test.cpp
• tests/lazy_avl_tree.test.cpp
• tests/lca.test.cpp
• tests/less_by_arg.test.cpp
• tests/less_by_arg_total.test.cpp
• tests/less_equal_moebius.test.cpp
• tests/less_equal_zeta.test.cpp
• tests/linear_sieve.test.cpp
• tests/log_mod.test.cpp
• tests/logn_integer_partition.test.cpp
• tests/longest_common_substring.test.cpp
• tests/make_signed.test.cpp
• tests/make_unsigned.test.cpp
• tests/make_wider.test.cpp
• tests/manacher.test.cpp
• tests/max_matching.test.cpp
• tests/median_heap.test.cpp
• tests/mex.test.cpp
• tests/midpoint.test.cpp
• tests/mo.test.cpp
• tests/mod.test.cpp
• tests/modint.test.cpp
• tests/modint_compatible.test.cpp
• tests/monoid.test.cpp
• tests/monoids.test.cpp
• tests/multiple_moebius.test.cpp
• tests/multiple_zeta.test.cpp
• tests/multiplicative_structure.test.cpp
• tests/multiset.test.cpp
• tests/multisort.test.cpp
• tests/multivariate_convolution.test.cpp
• tests/mutable_type.test.cpp
• tests/naive_dijkstra.test.cpp
• tests/next_combination.test.cpp
• tests/next_integer_partition.test.cpp
• tests/next_matching.test.cpp
• tests/next_permutation.test.cpp
• tests/non_bool_integral.test.cpp
• tests/online_cumsum.test.cpp
• tests/online_imos.test.cpp
• tests/or_convolution.test.cpp
• tests/pdsu.test.cpp
• tests/permutation.test.cpp
• tests/persistent_array.test.cpp
• tests/persistent_dual_segtree.test.cpp
• tests/persistent_queue.test.cpp
• tests/persistent_segtree.test.cpp
• tests/persistent_stack.test.cpp
• tests/polynomial_interpolation.test.cpp
• tests/polynomial_product.test.cpp
• tests/popcount.test.cpp
• tests/preset_segtree_beats.test.cpp
• tests/prime_static_modint.test.cpp
• tests/primitive_root.test.cpp
• tests/qcfium.test.cpp
• tests/quo.test.cpp
• tests/random_tree.test.cpp
• tests/range_count_distinct.test.cpp
• tests/range_parallel_dsu.test.cpp
• tests/rational_binary_search.test.cpp
• tests/real_interval_set.test.cpp
• tests/rectangle_union_area.test.cpp
• tests/rerooting_dp.test.cpp
• tests/resize.test.cpp
• tests/reverse.test.cpp
• tests/rolling_hash.test.cpp
• tests/rotl.test.cpp
• tests/rotr.test.cpp
• tests/run_length.test.cpp
• tests/safe_int.test.cpp
• tests/sample_point_shift.test.cpp
• tests/second_order_imos.test.cpp
• tests/set.test.cpp
• tests/small_range_lower_bound.test.cpp
• tests/sparse_segtree.test.cpp
• tests/sqrt_mod.test.cpp
• tests/stern_brocot_tree.test.cpp
• tests/subset_convolution.test.cpp
• tests/subset_moebius.test.cpp
• tests/subset_sum.test.cpp
• tests/subset_zeta.test.cpp
• tests/suffix_array.test.cpp
• tests/superset_moebius.test.cpp
• tests/superset_zeta.test.cpp
• tests/swag.test.cpp
• tests/tetration_mod.test.cpp
• tests/totient.test.cpp
• tests/transposed.test.cpp
• tests/tree_diameter.test.cpp
• tests/triangular_array.test.cpp
• tests/triangular_array_compressor.test.cpp
• tests/tsp.test.cpp
• tests/tuple_hash.test.cpp
• tests/uint128_t.test.cpp
• tests/util.test.cpp
• tests/xor_basis.test.cpp
• tests/xor_convolution.test.cpp

tests/avl_tree/

• tests/avl_tree/binary_search.test.cpp
• tests/avl_tree/reverse.test.cpp
• tests/avl_tree/set.test.cpp

tests/bell/

• tests/bell/all.test.cpp
• tests/bell/consistent.test.cpp
• tests/bell/diagonal.test.cpp
• tests/bell/fixed_n.test.cpp

tests/bigdecimal/

• tests/bigdecimal/cast_to_long_long.test.cpp
• tests/bigdecimal/divides.test.cpp
• tests/bigdecimal/hand.test.cpp
• tests/bigdecimal/minus.test.cpp
• tests/bigdecimal/multiplies.test.cpp
• tests/bigdecimal/plus.test.cpp
• tests/bigdecimal/random.test.cpp
• tests/bigdecimal/rounding.test.cpp

tests/bigint/

• tests/bigint/divides.test.cpp
• tests/bigint/extgcd.test.cpp
• tests/bigint/gcd.test.cpp
• tests/bigint/minus.test.cpp
• tests/bigint/modulus.test.cpp
• tests/bigint/multiplies.test.cpp
• tests/bigint/plus.test.cpp

tests/cartesian_tree/

• tests/cartesian_tree/parent.test.cpp
• tests/cartesian_tree/tree_based_interval.test.cpp
• tests/cartesian_tree/value_based_interval.test.cpp

tests/circle_2d/

• tests/circle_2d/intersection_to_circle.test.cpp
• tests/circle_2d/intersection_to_line.test.cpp

tests/circle_2d/where/

• tests/circle_2d/where/with_radius.test.cpp
• tests/circle_2d/where/without_radius.test.cpp

tests/convolution/

• tests/convolution/double.test.cpp
• tests/convolution/dynamic_mod.test.cpp
• tests/convolution/mod1000000007.test.cpp
• tests/convolution/mod998244353.test.cpp

tests/cycle_detection/

• tests/cycle_detection/directed.test.cpp
• tests/cycle_detection/undirected.test.cpp

tests/dijkstra/

• tests/dijkstra/directed.test.cpp
• tests/dijkstra/undirected.test.cpp

tests/directed_line_segment_2d/

• tests/directed_line_segment_2d/cross_point.test.cpp
• tests/directed_line_segment_2d/crosses.test.cpp
• tests/directed_line_segment_2d/intersection.test.cpp
• tests/directed_line_segment_2d/squared_distance.test.cpp

tests/fastio/

• tests/fastio/integer.test.cpp
• tests/fastio/string.test.cpp

tests/fds_with_prefix_sums/

• tests/fds_with_prefix_sums/division.test.cpp
• tests/fds_with_prefix_sums/multiplication.test.cpp
• tests/fds_with_prefix_sums/sum_of_totient_function.test.cpp

tests/fps/

• tests/fps/composition.test.cpp
• tests/fps/compositional_inverse.test.cpp
• tests/fps/exp_mod998244353.test.cpp
• tests/fps/exp_other_mods.test.cpp
• tests/fps/inv_mod998244353.test.cpp
• tests/fps/inv_other_mods.test.cpp
• tests/fps/log_mod998244353.test.cpp
• tests/fps/log_other_mods.test.cpp
• tests/fps/pow_mod998244353.test.cpp
• tests/fps/pow_other_mods.test.cpp

tests/gcd_convolution/

• tests/gcd_convolution/different_lengths.test.cpp
• tests/gcd_convolution/regular.test.cpp

tests/hld/

• tests/hld/epath.test.cpp
• tests/hld/lca.test.cpp
• tests/hld/vancestor.test.cpp
• tests/hld/vpath.test.cpp
• tests/hld/vsubtree.test.cpp

tests/large_fact_mod_cache/

• tests/large_fact_mod_cache/binomial.test.cpp
• tests/large_fact_mod_cache/fact.test.cpp

tests/lazy_segtree/

• tests/lazy_segtree/dual_segtree.test.cpp
• tests/lazy_segtree/segtree.test.cpp

tests/lazy_segtree/lazy_segtree/

• tests/lazy_segtree/lazy_segtree/binary_search.test.cpp
• tests/lazy_segtree/lazy_segtree/prod_and_apply.test.cpp

tests/lazy_sparse_segtree/

• tests/lazy_sparse_segtree/binary_search.test.cpp
• tests/lazy_sparse_segtree/prod_and_apply.test.cpp

tests/lcm_convolution/

• tests/lcm_convolution/different_lengths.test.cpp
• tests/lcm_convolution/regular.test.cpp

tests/li_chao_segtree/

• tests/li_chao_segtree/line.test.cpp
• tests/li_chao_segtree/segment.test.cpp

tests/line_2d/

• tests/line_2d/is_parallel_to.test.cpp
• tests/line_2d/projection.test.cpp

tests/lis/bisect/

• tests/lis/bisect/no_restore.test.cpp
• tests/lis/bisect/restore.test.cpp

tests/lis/segtree/

• tests/lis/segtree/no_restore.test.cpp
• tests/lis/segtree/restore.test.cpp

tests/lowlink/

• tests/lowlink/biconnected_components.test.cpp
• tests/lowlink/is_bridge.test.cpp
• tests/lowlink/ncc_without_vertex.test.cpp

tests/matrix/

• tests/matrix/determinant.test.cpp
• tests/matrix/inv.test.cpp
• tests/matrix/multiplies.test.cpp
• tests/matrix/rank.test.cpp
• tests/matrix/ring.test.cpp
• tests/matrix/solve.test.cpp
• tests/matrix/static.test.cpp

tests/matrix_mod2/

• tests/matrix_mod2/determinant.test.cpp
• tests/matrix_mod2/inv.test.cpp
• tests/matrix_mod2/multiplies.test.cpp
• tests/matrix_mod2/rank.test.cpp
• tests/matrix_mod2/solve.test.cpp

tests/minimum_steiner_tree/

• tests/minimum_steiner_tree/no_restore.test.cpp
• tests/minimum_steiner_tree/restore.test.cpp

tests/ord_mod/

• tests/ord_mod/count.test.cpp
• tests/ord_mod/query.test.cpp

tests/partially_persistent_dsu/

• tests/partially_persistent_dsu/same_and_size.test.cpp
• tests/partially_persistent_dsu/when_connected.test.cpp

tests/partition_function/

• tests/partition_function/all.test.cpp
• tests/partition_function/consistent.test.cpp
• tests/partition_function/diagonal.test.cpp

tests/persistent_lazy_segtree/

• tests/persistent_lazy_segtree/binary_search.test.cpp
• tests/persistent_lazy_segtree/prod_apply_and_rollback.test.cpp

tests/polygon_2d/

• tests/polygon_2d/area.test.cpp
• tests/polygon_2d/minimum_bounding_circle.test.cpp
• tests/polygon_2d/where.test.cpp

tests/polynomial/

• tests/polynomial/extgcd.test.cpp
• tests/polynomial/multidimensional.test.cpp
• tests/polynomial/multipoint_evaluation.test.cpp
• tests/polynomial/multipoint_evaluation_other_mods.test.cpp
• tests/polynomial/naive_division.test.cpp
• tests/polynomial/ntt_division.test.cpp
• tests/polynomial/taylor_shift.test.cpp

tests/preset_wavelet_matrix/

• tests/preset_wavelet_matrix/static.test.cpp
• tests/preset_wavelet_matrix/updatable.test.cpp

tests/prim/

• tests/prim/basic.test.cpp
• tests/prim/unconnected.test.cpp

tests/prime_factorization/

• tests/prime_factorization/regular.test.cpp
• tests/prime_factorization/severe_cases.test.cpp

tests/quaternion/

• tests/quaternion/angle_axis.test.cpp
• tests/quaternion/dice_rotations.test.cpp
• tests/quaternion/look_rotation.test.cpp
• tests/quaternion/slerp.test.cpp

tests/rational/

• tests/rational/minus.test.cpp
• tests/rational/multiplies.test.cpp
• tests/rational/plus.test.cpp
• tests/rational/random.test.cpp

tests/scc_graph/

• tests/scc_graph/edges_to_scc.test.cpp
• tests/scc_graph/scc_id.test.cpp
• tests/scc_graph/sccs.test.cpp

tests/segmented_sieve/

• tests/segmented_sieve/comprehensive.test.cpp
• tests/segmented_sieve/prime_factor_range.test.cpp

tests/sparse_fps_pow/

• tests/sparse_fps_pow/fraction.test.cpp
• tests/sparse_fps_pow/regular.test.cpp

tests/stirling_1st/

• tests/stirling_1st/consistent.test.cpp
• tests/stirling_1st/fixed_k.test.cpp
• tests/stirling_1st/fixed_n.test.cpp

tests/stirling_2nd/

• tests/stirling_2nd/all.test.cpp
• tests/stirling_2nd/consistent.test.cpp
• tests/stirling_2nd/fixed_k.test.cpp
• tests/stirling_2nd/fixed_n.test.cpp

tests/triangle_2d/

• tests/triangle_2d/incircle.test.cpp

tests/triangle_2d/circumcircle/

• tests/triangle_2d/circumcircle/double.test.cpp
• tests/triangle_2d/circumcircle/rational.test.cpp

tests/tsort/

• tests/tsort/count.test.cpp
• tests/tsort/query.test.cpp

tests/twelvefold_way/

• tests/twelvefold_way/labeled_ball_labeled_box_at_least_1.test.cpp
• tests/twelvefold_way/labeled_ball_labeled_box_at_most_1.test.cpp
• tests/twelvefold_way/labeled_ball_labeled_box_unrestricted.test.cpp
• tests/twelvefold_way/labeled_ball_unlabeled_box_at_least_1.test.cpp
• tests/twelvefold_way/labeled_ball_unlabeled_box_at_most_1.test.cpp
• tests/twelvefold_way/labeled_ball_unlabeled_box_unrestricted.test.cpp
• tests/twelvefold_way/unlabeled_ball_labeled_box_at_least_1.test.cpp
• tests/twelvefold_way/unlabeled_ball_labeled_box_at_most_1.test.cpp
• tests/twelvefold_way/unlabeled_ball_labeled_box_unrestricted.test.cpp
• tests/twelvefold_way/unlabeled_ball_unlabeled_box_at_least_1.test.cpp
• tests/twelvefold_way/unlabeled_ball_unlabeled_box_at_most_1.test.cpp
• tests/twelvefold_way/unlabeled_ball_unlabeled_box_unrestricted.test.cpp

tests/undoable_dsu/

• tests/undoable_dsu/leader.test.cpp
• tests/undoable_dsu/ncc.test.cpp

tests/wavelet_matrix/

• tests/wavelet_matrix/kth_smallest.test.cpp
• tests/wavelet_matrix/next_points.test.cpp
• tests/wavelet_matrix/prev_points.test.cpp
• tests/wavelet_matrix/range_freq.test.cpp
• tests/wavelet_matrix/range_prod.test.cpp

tests/weighted_bipartite_matching/

• tests/weighted_bipartite_matching/maximize.test.cpp
• tests/weighted_bipartite_matching/minimize.test.cpp
• tests/weighted_bipartite_matching/multiple_calls.test.cpp

tests/zero_one_bfs/

• tests/zero_one_bfs/directed.test.cpp
• tests/zero_one_bfs/undirected.test.cpp

tests/zero_one_knapsack/

• tests/zero_one_knapsack/solve_by_dp_maximizing_value.test.cpp
• tests/zero_one_knapsack/solve_by_dp_minimizing_weight.test.cpp
• tests/zero_one_knapsack/solve_by_meet_in_the_middle.test.cpp